Comment on attachment 61145 [details]
27k bytes reduced testcase

>template <int a> struct b {
>  static const int c = a;
>};
>struct e {};
>template <int> struct aa;
>template <typename = e, typename = int> struct ab;
>template <> struct aa<1> {
>  template <typename h, typename, typename, typename, typename> struct ac {
>    typedef h d;
>  };
>};
>template <> struct aa<2> {
>  template <typename, typename ad, typename, typename, typename> struct ac {
>    typedef ad d;
>  };
>};
>template <typename> struct ae {};
>template <typename> struct as;
>template <typename g> struct ae<ae<g>> {
>  typedef g d;
>};
>template <class g, g af> struct i {
>  static const int c = af;
>};
>template <class, class> struct j : i<int, 0> {};
>template <class g> struct j<g, g> : i<int, 1> {};
>template <typename ag = e, typename g = e>
>struct ah : ae<typename ag::ai>::template ac<ag, g> {};
>template <> struct ah<> {
>  template <typename aj, typename ak> struct ac : ah<aj, ak> {};
>};
>template <int, typename aj, typename> struct al {
>  typedef aj d;
>};
>template <typename aj, typename ak> struct al<0, aj, ak> {
>  typedef ak d;
>};
>template <typename aj, typename ak, typename am> struct an {
>  typedef typename al<aj::c, ak, am>::d d;
>};
>template <int at> struct ao {
>  static const int c = at;
>  typedef ao<at + 1> ar;
>};
>template <typename aw, int ax> struct au {
>  typedef __typeof__(aw::av(ao<ax>())) d;
>};
>template <typename aw, int ax> struct bb : ae<typename au<aw, ax>::d> {};
>template <> struct as<int> {
>  template <typename aw, typename at> struct ac : bb<aw, at::c> {};
>};
>template <typename g> struct ar {
>  typedef typename g::ar d;
>};
>template <typename g, typename bc> struct ay : bc {
>  typedef typename bc::az ba;
>  typedef typename ba::ar az;
>  typedef typename ar<typename bc::bg>::d bg;
>  static ae<g> av(ba);
>  using bc::av;
>};
>template <> struct ae<int> {
>  template <typename aw, typename g> struct ac {
>    typedef ay<g, aw> d;
>  };
>};
>template <typename bd, typename aj, typename ak>
>struct be : bd::template ac<aj, ak> {};
>template <typename bd, typename aj, typename am>
>struct bf : bd::template ac<aj, int, am> {};
>template <typename bd, typename aj, typename ak>
>struct bl : bd::template ac<aj, ak, int, int, int> {};
>template <typename bh, typename bi, typename k = e> struct bj {
>  typedef typename an<bh, bi, k>::d ::d d;
>};
>template <int bh, typename bi, typename k> struct bk {
>  typedef typename al<bh, bi, k>::d ::d d;
>};
>template <typename aw, long ax> struct bp {
>  typedef typename bb<aw, ax>::d d;
>};
>template <typename aw, long ax> struct ar<bp<aw, ax>> {
>  typedef bp<aw, ax + 1> d;
>};
>struct bm {
>  typedef int ai;
>  typedef ao<0> az;
>  typedef ao<0> bg;
>  void av();
>};
>template <typename aw> struct ac : aw::bg {};
>struct bn {
>  template <typename aw> struct ac {
>    typedef bp<aw, 0> d;
>  };
>};
>template <typename bo> struct bv : ay<bo, bm> {};
>template <typename bo, typename aj> struct bq : ay<aj, bv<bo>> {};
>template <typename bo, typename aj, typename ak>
>struct br : ay<ak, bq<bo, aj>> {};
>template <typename bo, typename aj, typename ak, typename am>
>struct bs : ay<am, br<bo, aj, ak>> {};
>template <typename = e, typename = e, typename = e, typename = e, typename = e>
>struct bt;
>template <> struct bt<> : bm {};
>template <typename bo> struct bt<bo> : bv<bo> {};
>template <typename bo, typename aj, typename ak, typename am>
>struct bt<bo, aj, ak, am> : bs<bo, aj, ak, am> {};
>template <typename> struct allocator {
>  template <typename bu> allocator(bu) {}
>};
>template <typename> struct cf;
>template <typename bw> struct cf<allocator<bw>> {
>  using bx = bw *;
>  template <typename by> using bz = allocator<by>;
>  static bx allocate() { return (bx)__builtin_calloc(1, sizeof(bw)); }
>};
>template <class g> struct ca {
>  typedef g &d;
>};
>template <typename ag> struct begin {
>  typedef typename bn::ac<ag>::d d;
>};
>template <typename ag, int at>
>struct cb : as<typename ag::ai>::template ac<ag, ao<at>> {};
>template <typename g> struct cd : g {};
>template <typename, typename, typename, typename> struct ce;
>template <int at, typename h, typename ad, typename cp>
>struct ce<aa<at>, h, ad, cp> {
>  typedef typename bl<aa<at>, h, ad>::d d;
>};
>struct l;
>template <typename, typename, typename> struct cg {
>  template <typename, typename ad> struct ac {
>    typedef typename be<l, typename ce<aa<2>, int, ad, int>::d,
>                        typename ce<aa<1>, int, ad, int>::d>::d d;
>  };
>};
>template <template <typename, typename, typename> class> struct ch;
>struct m;
>template <typename am> struct ci {
>  template <typename h, typename ad> struct ac {
>    typedef typename bf<ch<an>, m, typename ce<am, h, ad, int>::d>::d d;
>  };
>};
>template <typename bd, typename aj, typename ak, typename, typename, typename>
>struct cj {
>  template <typename h, typename ad, typename, typename, typename> struct ac {
>    typedef typename bl<bd, typename ce<aj, h, ad, int>::d,
>                        typename ce<ak, h, ad, int>::d>::d d;
>  };
>};
>template <typename bd, typename aj, typename ak, typename am, typename ap,
>          typename aq, typename h, typename ad, typename cp>
>struct ce<cj<bd, aj, ak, am, ap, aq>, h, ad, cp> {
>  typedef typename bl<cj<bd, aj, ak, am, ap, aq>, h, ad>::d d;
>};
>template <typename g> struct ck {
>  typedef typename g::d d;
>};
>template <template <typename, typename, typename> class bd> struct ch {
>  template <typename h, typename, typename cl>
>  struct ac : ck<bd<h, int, cl>> {};
>};
>template <template <typename, typename, typename, typename, typename> class bd>
>struct cw {
>  template <typename h, typename ad, typename, typename, typename>
>  struct ac : ck<bd<h, ad, int, int, int>> {};
>};
>template <typename g, typename> struct ab {
>  typedef g cm;
>  typedef g d;
>};
>template <typename bd, typename aj, typename ak, typename cn>
>struct ab<cg<bd, aj, ak>, cn> {
>  typedef cg<bd, aj, ak> d;
>};
>template <typename co> struct da {
>  typedef cd<ci<typename co::cm>> d;
>};
>template <template <typename, typename, typename> class bd, typename aj,
>          typename ak, typename am, typename cn>
>struct ab<bd<aj, ak, am>, cn> {
>  typedef typename da<ab<am>>::d d;
>};
>template <typename,
>          template <typename, typename, typename, typename, typename> class,
>          typename, typename, typename, typename, typename>
>struct cq;
>template <template <typename, typename, typename, typename, typename> class bd,
>          typename cr, typename cs, typename co, typename ct, typename cu>
>struct cq<b<1>, bd, cr, cs, co, ct, cu> {
>  typedef cj<cw<bd>, typename cr::cm, typename cs::cm, typename co::cm,
>             typename ct::cm, typename cu::cm>
>      cm;
>};
>template <template <typename, typename, typename, typename, typename> class bd,
>          typename aj, typename ak, typename am, typename ap, typename aq,
>          typename cn>
>struct ab<bd<aj, ak, am, ap, aq>, cn> {
>  typedef typename cq<b<1>, bd, ab<aj>, ab<ak>, ab<>, ab<>, ab<>>::cm cm;
>};
>template <typename bd, typename aj, typename ak>
>struct cv : be<typename ab<bd>::d, aj, ak> {};
>template <typename ak> struct n {
>  typedef ak dl;
>};
>template <typename g> struct cx {
>  typedef g d;
>};
>template <typename ag> struct o {
>  typedef n<typename begin<ag>::d> d;
>};
>template <typename ag> struct p {
>  typedef typename o<ag>::d ::dl d;
>};
>template <int, typename, typename, typename> struct q;
>template <typename cy, typename cz, typename s> struct q<4, cy, cz, s> {
>  typedef cy t;
>  typedef typename ar<t>::d v;
>  typedef typename ar<v>::d u;
>  typedef typename ar<u>::d x;
>  typedef typename cv<
>      s,
>      typename cv<s,
>                  typename cv<s, typename cv<s, cz, typename t::d>::d,
>                              typename v::d>::d,
>                  typename u::d>::d,
>      typename x::d>::d db;
>};
>template <typename ag, typename cz, typename s> struct dc {
>  typedef typename q<ac<ag>::c, typename begin<ag>::d, cz, s>::db d;
>};
>struct y {
>  typedef bt<> db;
>  typedef ah<> dd;
>};
>template <typename, typename, typename> struct w;
>template <typename de, typename g> struct df {
>  typedef typename cf<de>::template bz<g> d;
>};
>template <int, typename, typename, typename> struct dg;
>template <typename cy, typename dh, typename s> struct dg<2, cy, dh, s> {
>  typedef cy t;
>  typedef typename cv<dh, typename cv<dh, int, typename ar<t>::d>::d, t>::d db;
>};
>template <typename ag, typename dh> struct dj {
>  typedef typename dg<ac<ag>::c, typename begin<ag>::d, dh, int>::db d;
>};
>template <typename dk, typename Final> struct dm {
>  dm() : member(static_cast<Final *>(this)->z()) {}
>  dk member;
>};
>template <typename Value, typename de> struct index_node_base {
>  int space;
>  typedef Value cc;
>  typedef de allocator_type;
>  cc &c() { return *reinterpret_cast<cc *>(&space); }
>};
>struct l {
>  template <typename IndexSpecifierIterator, typename> struct ac {
>    typedef typename IndexSpecifierIterator::d ::template node_class<int>::d d;
>  };
>};
>template <typename IndexSpecifierList> struct multi_index_node_type {
>  typedef typename dj<IndexSpecifierList, cg<int, int, int>>::d d;
>};
>template <typename g> struct add_pointer {
>  typedef g *d;
>};
>template <class TT> struct cons {
>  TT tail;
>};
>template <typename Value, typename IndexSpecifierList, typename de>
>struct index_base {
>  typedef typename multi_index_node_type<IndexSpecifierList>::d final_node_type;
>  typedef w<Value, IndexSpecifierList, de> final_type;
>  typedef int ctor_args_list;
>  typedef typename df<de, int>::d final_allocator_type;
>  typedef bm index_type_list;
>  typedef Value cc;
>  index_base(ctor_args_list, de) {}
>  final_node_type *insert_(cc, final_node_type *&p2) {
>    return p2 = final().z();
>  }
>  void replace_(cc p1, index_node_base<Value, de> *p2, int) { p2->c() = p1; }
>  final_type final() { return *static_cast<final_type *>(this); }
>  final_node_type *final_header() { return final().header(); }
>  final_node_type *final_insert_(cc p1) { return final().insert_(p1); }
>  void final_replace_rv_(cc p1, final_node_type *p2) {
>    final().replace_rv_(p1, p2);
>  }
>};
>struct index_applier {
>  template <typename IndexSpecifierMeta, typename SuperMeta> struct ac {
>    typedef
>        typename IndexSpecifierMeta::d ::template index_class<SuperMeta>::d d;
>  };
>};
>template <int at, typename Value, typename IndexSpecifierList, typename de>
>struct nth_layer {
>  typedef
>      typename bk<at == ao<2>::c, cx<index_base<Value, IndexSpecifierList, de>>,
>                  cv<index_applier, cb<IndexSpecifierList, at>,
>                     nth_layer<at + 1, Value, IndexSpecifierList, de>>>::d d;
>};
>template <class, class, class, bool> struct mutant_relation;
>template <typename IndexSpecifierList, typename de>
>struct multi_index_base_type
>    : nth_layer<0, mutant_relation<int, int, e, 1>, IndexSpecifierList, de> {};
>template <typename Value, typename IndexSpecifierList, typename de>
>struct w
>    : dm<typename cf<typename df<
>             de, typename multi_index_node_type<IndexSpecifierList>::d>::d>::bx,
>         w<Value, IndexSpecifierList, de>>,
>      multi_index_base_type<IndexSpecifierList, de>::d {
>  typedef typename multi_index_base_type<IndexSpecifierList, de>::d super;
>  typedef cf<typename df<de, typename super::index_node_type>::d>
>      node_alloc_traits;
>  typedef dm<typename node_alloc_traits::bx, w> bfm_header;
>  typedef typename super::final_node_type final_node_type;
>  w(typename super::final_allocator_type)
>      : super(typename super::ctor_args_list(), 0) {}
>  template <typename> struct index {
>    typedef typename p<typename super::index_type_list>::d ::d d;
>  };
>  final_node_type *header() { return bfm_header::member; }
>  final_node_type *z() { return node_alloc_traits::allocate(); }
>  final_node_type *insert_(Value p1) { return super::insert_(p1, 0); }
>  void replace_rv_(Value p1, final_node_type *p2) {
>    super::replace_(p1, p2, 0);
>  }
>};
>template <class, class Type> mutant_relation<int, int, e, 0> &mutate(Type &p1) {
>  return *reinterpret_cast<mutant_relation<int, int, e, 0> *>(
>      __builtin_addressof(p1));
>}
>struct relation_info_hook {
>  int right;
>  relation_info_hook(int, int p2) : right(p2) {}
>};
>template <class, class, class Info, bool>
>struct mutant_relation : relation_info_hook {
>  typedef mutant_relation<int, int, Info, 0> above_view;
>  mutant_relation(int, int p2) : relation_info_hook(0, p2) {}
>  mutant_relation(const mutant_relation<int, int, Info, 0> &p1)
>      : relation_info_hook(p1) {}
>  above_view &get_view() { return mutate<above_view>(*this); }
>};
>template <class TA, class TB, bool force_mutable>
>mutant_relation<TA, TB, e, 0>
>copy_with_right_replaced(mutant_relation<TA, TB, e, force_mutable>, int p2) {
>  return mutant_relation<TA, TB, e, 0>(0, p2);
>}
>struct m : i<int, 0> {};
>struct use_default;
>template <class ValueParam> struct iterator_facade_types {
>  typedef typename bj<b<1>, add_pointer<ValueParam>>::d bx;
>};
>template <class g, class Pointer> struct operator_arrow_dispatch {
>  static Pointer ac(g p1) { return __builtin_addressof(p1); }
>};
>template <class, class, class, class, int> struct iterator_facade_base;
>template <class Derived, class Value, class Reference, class Difference>
>struct iterator_facade_base<Derived, Value, Reference, Difference, 0> {
>  typedef iterator_facade_types<Value> associated_types;
>  typedef Reference reference;
>  reference operator*() { return derived().dereference(); }
>  typename associated_types::bx operator->() {
>    return operator_arrow_dispatch<
>        Reference, typename associated_types::bx>::ac(*derived());
>  }
>  Derived derived() { return *static_cast<Derived *>(this); }
>};
>template <class Derived, class Value, class Reference>
>struct iterator_facade
>    : iterator_facade_base<Derived, Value, Reference, int, i<int, 0>::c> {};
>template <class g, class DefaultNullaryFn>
>struct ia_dflt_help : bj<j<g, use_default>, DefaultNullaryFn, cx<g>> {};
>template <class Derived, class Value, class Reference>
>struct iterator_adaptor_base {
>  typedef iterator_facade<
>      Derived, typename ia_dflt_help<Value, int>::d,
>      typename ia_dflt_help<Reference,
>                            bj<j<Value, use_default>, int, ca<Value>>>::d>
>      d;
>};
>template <class Derived, class bc, class Value, class Reference = use_default>
>struct Trans_NS_iterators_iterator_adaptor
>    : iterator_adaptor_base<Derived, Value, Reference>::d {
>  Trans_NS_iterators_iterator_adaptor(bc p1) : m_iterator(p1) {}
>  typedef bc base_type;
>  bc m_iterator;
>};
>template <typename Node> struct bidir_node_iterator {
>  bidir_node_iterator(Node *p1) : node(p1) {}
>  typename Node::cc &operator*() { return node->c(); }
>  Node *node;
>};
>template <typename> struct ordered_index_node_impl_;
>struct null_augment_policy;
>struct ordered_index_node_compressed_base {
>  typedef ordered_index_node_impl_<allocator<char>> *bx;
>  struct parent_ref {
>    parent_ref(long *p1) : r(p1) {}
>    operator bx() { return bx(*r); }
>    long *r;
>  };
>  parent_ref parent() { return &parentcolor_; }
>  long parentcolor_;
>};
>template <typename AugmentPolicy, typename>
>struct ordered_index_node_impl_base
>    : AugmentPolicy::template augmented_node<int>::d {};
>template <typename de>
>struct ordered_index_node_impl_
>    : ordered_index_node_impl_base<null_augment_policy, de> {
>  typedef typename ordered_index_node_impl_base<null_augment_policy, de>::bx bx;
>  static void link(bx p1, bx p2) { *p2->parent().r = (long)p1; }
>};
>template <typename Super>
>struct ordered_index_node_trampoline
>    : ordered_index_node_impl_<
>          typename df<typename Super::allocator_type, char>::d> {
>  typedef ordered_index_node_impl_<int> impl_type;
>};
>template <typename Super>
>struct ordered_index_node : Super, ordered_index_node_trampoline<Super> {
>  static ordered_index_node *
>  from_impl_(typename ordered_index_node_trampoline<Super>::bx p1) {
>    return static_cast<ordered_index_node *>(p1);
>  }
>};
>template <typename SuperMeta> struct ordered_index_impl_ : SuperMeta::d {
>  typedef typename SuperMeta::d super;
>  typedef ordered_index_node<typename super::index_node_type> index_node_type;
>  typedef typename index_node_type::impl_type node_impl_type;
>  typedef typename index_node_type::cc cc;
>  typedef bidir_node_iterator<index_node_type> dn;
>  typedef typename super::final_node_type final_node_type;
>  typedef cons<typename super::ctor_args_list> ctor_args_list;
>  dn insert(cc p1) { return this->final_insert_(p1); }
>  void replace(dn p1, cc p2) { this->final_replace_rv_(p2, p1.node); }
>  template <typename CompatibleKey> dn find(CompatibleKey) {
>    return index_node_type::from_impl_(this->final_header()->parent());
>  }
>  ordered_index_impl_(ctor_args_list p1, typename super::final_allocator_type)
>      : super(p1.tail, 0) {}
>  final_node_type *insert_(cc p1, final_node_type *p2) {
>    final_node_type *f = super::insert_(p1, p2);
>    node_impl_type::link(p2, this->final_header());
>    return f;
>  }
>};
>template <typename SuperMeta, typename AugmentPolicy>
>struct ordered_index : AugmentPolicy::template augmented_interface<
>                           ordered_index_impl_<SuperMeta>>::d {
>  typedef typename AugmentPolicy::template augmented_interface<
>      ordered_index_impl_<SuperMeta>>::d super;
>  ordered_index(typename super::ctor_args_list p1,
>                typename super::allocator_type)
>      : super(p1, 0) {}
>};
>struct null_augment_policy {
>  template <typename OrderedIndexImpl_> struct augmented_interface {
>    typedef OrderedIndexImpl_ d;
>  };
>  template <typename> struct augmented_node {
>    typedef ordered_index_node_compressed_base d;
>  };
>};
>struct ordered_unique {
>  template <typename> struct node_class {
>    typedef ordered_index_node<
>        index_node_base<mutant_relation<int, int, e, 1>, allocator<char>>>
>        d;
>  };
>  template <typename SuperMeta> struct index_class {
>    typedef ordered_index<SuperMeta, null_augment_policy> d;
>  };
>};
>template <class BaseIterator, class di> struct iterator_from_base_identity {
>  di operator()(BaseIterator p1) { return p1; }
>};
>template <typename Types_, typename Node_, typename Root_ = e>
>struct inherit_linearly : dc<Types_, Root_, Node_> {};
>template <typename aj, typename ak> struct inherit2 : aj, ak {
>  typedef inherit2 d;
>};
>template <typename aj, typename ak, typename = e, typename = e, typename = e>
>struct inherit5 : inherit2<aj, ak> {};
>template <class Data, class FunctorList>
>struct data_with_functor_bag
>    : inherit_linearly<FunctorList, an<m, int, inherit5<aa<1>, aa<2>>>>::d {
>  Data data;
>  data_with_functor_bag(Data p1) : data(p1) {}
>};
>template <typename ag, typename Inserter>
>struct copy_impl_ : dc<ag, typename Inserter::db, typename Inserter::dd> {};
>template <class bc, class di, class IteratorToBaseConverter>
>struct Trans_NS_container_adaptor_container_adaptor {
>  typedef di dn;
>  typedef iterator_from_base_identity<dn, dn> iterator_from_base;
>  Trans_NS_container_adaptor_container_adaptor(bc &p1) : dwfb(p1) {}
>  typedef bc base_type;
>  template <class Functor> Functor functor() { return dwfb; }
>  data_with_functor_bag<
>      bc &,
>      typename copy_impl_<bt<typename an<b<0>, int, IteratorToBaseConverter>::d,
>                             iterator_from_base>,
>                          y>::d>
>      dwfb;
>};
>template <class bc, class di, class IteratorToBaseConverter>
>struct associative_container_adaptor_base {
>  typedef Trans_NS_container_adaptor_container_adaptor<bc, di,
>                                                       IteratorToBaseConverter>
>      d;
>};
>template <class bc, class di, class IteratorToBaseConverter>
>struct associative_container_adaptor
>    : associative_container_adaptor_base<bc, di, IteratorToBaseConverter>::d {
>  typedef typename associative_container_adaptor_base<
>      bc, di, IteratorToBaseConverter>::d base_;
>  associative_container_adaptor(bc &p1) : base_(p1) {}
>  auto find() {
>    return this->template functor<typename base_::iterator_from_base>()(
>        this->dwfb.data.find(0));
>  }
>};
>template <class bc, class di, class IteratorToBaseConverter>
>struct ordered_associative_container_adaptor_base {
>  typedef associative_container_adaptor<bc, di, IteratorToBaseConverter> d;
>};
>template <class bc, class di, class IteratorToBaseConverter>
>struct ordered_associative_container_adaptor
>    : ordered_associative_container_adaptor_base<bc, di,
>                                                 IteratorToBaseConverter>::d {
>  typedef typename ordered_associative_container_adaptor_base<
>      bc, di, IteratorToBaseConverter>::d base_;
>  ordered_associative_container_adaptor(bc &p1) : base_(p1) {}
>};
>template <class bc, class IteratorToBaseConverter>
>struct map_adaptor
>    : ordered_associative_container_adaptor<bc, int, IteratorToBaseConverter> {
>  map_adaptor(bc p1)
>      : ordered_associative_container_adaptor<bc, int, IteratorToBaseConverter>(
>            p1) {}
>};
>template <class di> struct iterator_facade_to_base {
>  typename di::base_type operator()(di p1) { return p1.m_iterator; }
>};
>template <class BimapType>
>struct map_view
>    : map_adaptor<typename BimapType::core_type::template index<int>::d,
>                  iterator_facade_to_base<
>                      Trans_NS_iterators_iterator_adaptor<int, int, int>>> {
>  typedef map_adaptor<typename BimapType::core_type::template index<int>::d,
>                      iterator_facade_to_base<
>                          Trans_NS_iterators_iterator_adaptor<int, int, int>>>
>      base_;
>  map_view(typename base_::base_type p1) : base_(p1) {}
>};
>template <class bc, class di, class IteratorToBaseConverter>
>struct set_adaptor
>    : ordered_associative_container_adaptor<bc, di, IteratorToBaseConverter> {
>  set_adaptor(bc &p1)
>      : ordered_associative_container_adaptor<bc, di, IteratorToBaseConverter>(
>            p1) {}
>};
>struct set_view_iterator
>    : Trans_NS_iterators_iterator_adaptor<
>          set_view_iterator,
>          bidir_node_iterator<ordered_index_node<index_node_base<
>              mutant_relation<int, int, e, 1>, allocator<char>>>>,
>          mutant_relation<int, int, e, 0>> {
>  set_view_iterator(
>      bidir_node_iterator<ordered_index_node<
>          index_node_base<mutant_relation<int, int, e, 1>, allocator<char>>>>
>          p1)
>      : Trans_NS_iterators_iterator_adaptor(p1) {}
>  reference dereference() { return (&*m_iterator)->get_view(); }
>};
>template <class CoreIndex>
>struct set_view : set_adaptor<CoreIndex, set_view_iterator,
>                              iterator_facade_to_base<set_view_iterator>> {
>  typedef set_adaptor<CoreIndex, set_view_iterator,
>                      iterator_facade_to_base<set_view_iterator>>
>      base_;
>  set_view(typename base_::base_type &p1) : base_(p1) {}
>  void replace_right(set_view_iterator p1, int p2) {
>    this->dwfb.data.replace(
>        this->template functor<iterator_facade_to_base<set_view_iterator>>()(
>            p1),
>        copy_with_right_replaced(*p1, p2));
>  }
>};
>struct set_of {
>  template <class, class BimapType> struct map_view_bind {
>    typedef map_view<BimapType> d;
>  };
>  template <class IndexType> struct set_view_bind {
>    typedef set_view<IndexType> d;
>  };
>};
>struct unordered_set_of;
>template <class RightSetType, class> struct bimap_core {
>  typedef set_of left_set_type;
>  typedef RightSetType right_set_type;
>  typedef int left_tag;
>  typedef int right_tag;
>  typedef typename an<b<0>, int,
>                      typename ah<bt<ordered_unique>,
>                                  typename right_set_type::template index_bind<
>                                      int, right_tag>::d>::d>::d
>      compl_ete_core_indices;
>  struct core_indices : compl_ete_core_indices {};
>  typedef w<int, core_indices, allocator<char>> core_type;
>  typedef typename left_set_type::set_view_bind<core_type>::d relation_set;
>};
>template <class BimapBaseType> struct left_map_view_type {
>  typedef typename BimapBaseType::left_set_type::template map_view_bind<
>      typename BimapBaseType::left_tag, BimapBaseType>::d d;
>};
>template <class BimapBaseType> struct right_map_view_type {
>  typedef typename BimapBaseType::right_set_type::template map_view_bind<
>      typename BimapBaseType::right_tag, BimapBaseType>::d d;
>};
>template <class AP1 = e>
>struct bimap : bimap_core<unordered_set_of, AP1>::relation_set {
>  typedef bimap_core<unordered_set_of, AP1> base_;
>  typename base_::core_type core;
>  typename left_map_view_type<base_>::d left;
>  typename right_map_view_type<base_>::d right;
>  bimap() : base_::relation_set(core), core(0), left(core), right(core) {}
>};
>template <typename SuperMeta> struct hashed_index : SuperMeta::d {
>  typedef typename SuperMeta::d super;
>  typedef index_node_base<mutant_relation<int, int, e, 1>, allocator<char>>
>      index_node_type;
>  typedef typename super::final_allocator_type allocator_type;
>  typedef cons<typename super::ctor_args_list> ctor_args_list;
>  typedef typename ah<typename super::index_type_list, hashed_index>::d
>      index_type_list;
>  hashed_index(ctor_args_list, allocator_type) : super(0, 0) {}
>};
>struct hashed_unique {
>  template <typename> struct node_class {
>    typedef index_node_base<mutant_relation<int, int, int, 0>, int> d;
>  };
>  template <typename SuperMeta> struct index_class {
>    typedef hashed_index<SuperMeta> d;
>  };
>};
>template <class bc, class IteratorToBaseConverter>
>struct unordered_associative_container_adaptor_base {
>  typedef associative_container_adaptor<bc, int, IteratorToBaseConverter> d;
>};
>template <class bc, class IteratorToBaseConverter>
>struct unordered_associative_container_adaptor
>    : unordered_associative_container_adaptor_base<bc,
>                                                   IteratorToBaseConverter>::d {
>  typedef typename unordered_associative_container_adaptor_base<
>      bc, IteratorToBaseConverter>::d base_;
>  unordered_associative_container_adaptor(bc p1) : base_(p1) {}
>};
>template <class bc, class IteratorToBaseConverter>
>struct unordered_map_adaptor
>    : unordered_associative_container_adaptor<bc, IteratorToBaseConverter> {
>  unordered_map_adaptor(bc p1)
>      : unordered_associative_container_adaptor<bc, IteratorToBaseConverter>(
>            p1) {}
>};
>template <class BimapType>
>struct unordered_map_view
>    : unordered_map_adaptor<
>          typename BimapType::core_type::template index<int>::d,
>          iterator_facade_to_base<
>              Trans_NS_iterators_iterator_adaptor<int, int, int>>> {
>  typedef unordered_map_adaptor<
>      typename BimapType::core_type::template index<int>::d,
>      iterator_facade_to_base<
>          Trans_NS_iterators_iterator_adaptor<int, int, int>>>
>      base_;
>  unordered_map_view(typename base_::base_type p1) : base_(p1) {}
>};
>struct unordered_set_of {
>  template <class, class> struct index_bind {
>    typedef hashed_unique d;
>  };
>  template <class, class> struct map_view_bind {
>    typedef unordered_map_view<bimap_core<unordered_set_of, e>> d;
>  };
>};
>int main() {
>  bimap d;
>  d.replace_right(d.dwfb.data.insert({0, 0}), 42);
>  if (d.find()->right != 42)
>    __builtin_abort();
>}