gcc/testsuite/g++.target/i386/pr122906-1.C

// { dg-do compile { target *-*-linux* } }
// { dg-options "-O3 -std=c++20 -ftrivial-auto-var-init=zero -march=x86-64-v3 -fPIC -w -mtls-dialect=gnu " }

template <int> using b = int;
template <typename, typename> struct e;
struct m {};
template <class> struct aa;
template <typename> struct j;
using h = aa<j<int>>;
template <typename> using a = h;
template <typename> using k = h;
template <typename d> struct p {
  d ad;
};
struct ac {};
template <typename> struct al;
template <typename g> struct al<g *> {
  typedef g &ah;
};
template <typename z> z ::i q(z);
struct w {
  e<m, m> *l;
  al<e<m, m> *>::ah operator*() { return *l; }
  bool operator==(w) { return l; }
};
template <typename g, int o> struct n {
  using af = g[o];
};
template <typename g, int o> struct ak {
  n<g, o>::af am;
};
void ab();
template <typename ai> void ar(ai r, ac) {
  ai ag;
  for (; r != ag; ++r)
    ab(), *r;
}
template <typename ai> void as(ai r, ac) { ar(r, q(r)); }
struct {
  template <typename ai> void aj(ai r, ai) { as(r, q(r)); }
} ao;
namespace ap {
template <int at> struct bb {
  static const bool ax = at;
};
} // namespace ap
using ap::bb;
namespace av {
template <class aq, aq> struct c;
template <bool au> struct c<bool, au> {
  static const bool ax = au;
  operator bb<au>() {
    void *bc;
    return *reinterpret_cast<bb<au> *>(bc);
  }
};
template <class, class> struct ae : c<bool, false> {};
template <class aq> struct ae<aq, aq> : c<bool, true> {};
namespace aw {
using namespace ap;
}
} // namespace av
namespace ap {
template <int> struct bd {
  typedef bd<1> bh;
};
} // namespace ap
namespace av {
namespace aw {
template <typename, typename = int> struct be;
template <int, typename, typename, typename, typename> struct bn : bb<true> {};
template <typename bg, typename bj, typename ay, typename az>
struct bn<false, bg, bj, ay, az> : bn<bg ::ax, bj, ay, az, bb<false>> {};
template <>
struct bn<false, bb<false>, bb<false>, bb<false>, bb<false>> : bb<false> {};
template <typename bg, typename bj = int, typename ay = bb<false>,
          typename az = bb<false>, typename bl = bb<false>>
struct br : bn<bg ::ax, bj, ay, az, bl> {};
} // namespace aw
template <class aq> struct bi {
  typedef aq h;
};
template <typename aq> bi<aq>::h bf();
template <class> struct ba : c<bool, false> {};
template <class aq> struct ba<aq const> : c<bool, true> {};
template <class aq> struct bk {
  typedef aq const h;
};
template <class aq> struct bq {
  typedef aq h;
};
template <class aq> struct bu {
  typedef aq::h h;
};
template <class bo> struct by {
  typedef bo ::ah h;
};
template <class aq> struct bm {
  typedef aq h;
};
template <class aq> struct bm<aq const> {
  typedef aq h;
};
namespace aw {
template <int, typename bg, typename> struct bp {
  typedef bg h;
};
template <typename bg, typename bj> struct bp<false, bg, bj> {
  typedef bj h;
};
template <typename bg, typename bj, typename ay = int> struct cg {
  typedef bp<bg::ax, bj, ay>::h h;
};
template <typename C, typename bt, typename cd = int> struct bs {
  typedef cg<C, bt, cd>::h ::h h;
};
template <int, typename, typename, typename, typename> struct bx;
template <typename bg, typename bj, typename ay, typename az>
struct bx<true, bg, bj, ay, az> : bx<bg ::ax, bj, ay, az, bb<true>> {};
template <>
struct bx<true, bb<true>, bb<true>, bb<true>, bb<true>> : bb<true> {};
template <typename bg, typename bj>
struct bw : bx<bg ::ax, bj, bb<true>, bb<true>, bb<true>> {};
} // namespace aw
template <typename bv, typename bz> struct cb {
  template <typename cc> static void ca(cc);
  template <typename ch, typename cc> static decltype(ca<cc>(bf<ch>())) cr(int);
  template <typename, typename> static int cr(...);
  static const bool ax = sizeof(cr<bv, bz>(0)) == 1;
};
template <typename bv, typename bz> struct cm {
  static const bool ax = cb<bv, bz>::ax;
};
template <class bv, class bz> struct cl {
  typedef cm<bv, bz> h;
};
template <typename bv, typename bz> struct ci {
  typedef cl<bv, bz>::h h;
};
template <typename bv, typename bz> struct co : ci<bv, bz>::h {};
template <class bv, class bz> struct ce : c<bool, co<bv, bz>::ax> {};
namespace aw {
template <typename aq> struct cf {
  typedef aq h;
};
} // namespace aw
template <int> struct arg {
  template <typename ck, typename> struct apply {
    typedef ck h;
  };
};
template <> struct arg<2> {
  template <typename, typename cu> struct apply {
    typedef cu h;
  };
};
struct cj {};
template <class cq> struct cx : aw::bs<ce<cq, cj>, aw::cf<cq>> {};
template <class bo> struct cw : cx<typename bo::i> {};
template <class ct, class cp, class dc>
struct cn : aw::bs<aw::bw<ce<ct, cj>, ce<dc, cp>>, aw::cf<ac>> {};
template <class aq> struct dd : aw::br<ce<aq, ac>, ce<aq, int>> {};
template <class cs, class ct> struct cz : cs, ct {};
template <class cp, class dc> struct da {
  typedef cn<cj, cp, dc>::h category;
  typedef aw::cg<ae<cj, int>, category, cz<category, cj>>::h h;
};
template <class cy, class cp, class dc>
struct s : aw::bs<dd<cy>, aw::cf<cy>, da<cp, dc>> {};
namespace aw {
template <typename df, typename bg> struct de : df::apply<bg> {};
template <typename df, typename bg, typename bj>
struct u : df::apply<bg, bj> {};
template <typename df, typename bg, typename bj>
struct db : df::apply<bg, bj> {};
template <typename aq> struct bh {
  typedef aq::bh h;
};
template <typename, typename, typename, typename> struct cv;
template <int dk, typename ck, typename cu, typename dm>
struct cv<arg<dk>, ck, cu, dm> {
  typedef db<arg<dk>, ck, cu>::h h;
};
template <typename df, typename bg> struct dh {
  template <typename ck, typename cu = int> struct apply {
    typedef de<df, typename cv<bg, ck, cu, int>::h>::h h;
  };
};
template <typename df, typename bg, typename ck, typename cu, typename dm>
struct cv<dh<df, bg>, ck, cu, dm> {
  typedef db<dh<df, bg>, ck, cu>::h h;
};
template <typename df, typename bg, typename bj> struct dg {
  template <typename ck, typename cu> struct apply {
    typedef u<df, typename cv<bg, ck, cu, int>::h,
              typename cv<bj, ck, cu, int>::h>::h h;
  };
};
template <typename aq> struct di {
  typedef aq::h h;
};
template <template <typename> class df> struct dl {
  template <typename ck> struct apply : di<df<ck>> {};
};
template <int dk, typename dn> struct be<arg<dk>, dn> {
  typedef bb<true> dj;
  typedef arg<dk> result_;
};
template <typename, template <typename> class, typename> struct x;
template <template <typename> class df, typename L1>
struct x<bb<true>, df, L1> {
  typedef dh<dl<df>, typename L1::result_> h;
};
template <template <typename> class df, typename bg, typename dn>
struct be<df<bg>, dn> {
  typedef be<bg> l1;
  typedef x<typename l1::dj, df, l1>::h h;
};
template <typename df, typename bg, typename bj>
struct apply2 : u<df, bg, bj> {};
} // namespace aw
namespace iterators {
struct always_bool2 {
  template <class, class> struct apply {
    typedef bool h;
  };
};
template <class cp, class cy, class dc> struct y {
  typedef s<cy, cp, dc>::h i;
};
template <class, class, class, class, class, bool> class iterator_facade_base;
struct iterator_core_access {
  template <class Facade> static Facade::ah dereference(Facade &r) {
    return r.dereference();
  }
  template <class Facade> static void increment(Facade &r) { r.increment(); }
  template <class Facade1, class Facade2>
  static bool equal(Facade1 &r, Facade2 p2) {
    return r.equal(p2);
  }
};
template <class Derived, class Value, class cy, class dc, class Difference>
struct iterator_facade_base<Derived, Value, cy, dc, Difference, false> {
  typedef dc ah;
  typedef y<Value, cy, dc>::i i;
  ah operator*() { return iterator_core_access::dereference(derived()); }
  void operator++() { iterator_core_access::increment(derived()); }
  Derived &derived() { return *static_cast<Derived *>(this); }
};
template <class Derived, class Value, class cy, class dc, class = long>
struct iterator_facade
    : iterator_facade_base<Derived, Value, cy, dc, int, ce<cj, int>::ax> {};
template <class Derived1, class V1, class TC1, class Reference1,
          class Difference1, class Derived2, class V2, class TC2,
          class Reference2, class Difference2>
bq<typename aw::apply2<always_bool2, Derived1, Derived2>::h>::h
operator==(iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const &r,
           iterator_facade<Derived2, V2, TC2, Reference2, Difference2> p2) {
  return iterator_core_access::equal(*static_cast<Derived1 const *>(&r),
                                     *static_cast<Derived2 *>(&p2));
}
} // namespace iterators
using iterators::iterator_facade;
template <class aq, class DefaultNullaryFn>
struct ia_dflt_help : aw::bs<ae<aq, int>, DefaultNullaryFn, aw::cf<aq>> {};
template <class Derived, class Base, class dc> struct iterator_adaptor_base {
  typedef iterator_facade<Derived, int, typename ia_dflt_help<int, cw<Base>>::h,
                          typename ia_dflt_help<dc, int>::h>
      h;
};
template <class Derived, class Base, class, class, class dc, class = int>
struct iterator_adaptor : iterator_adaptor_base<Derived, Base, dc>::h {
  Base an() const { return m_iterator; }
  template <class OtherDerived, class OtherIterator, class V, class C, class R,
            class D>
  bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D>) const {
    return m_iterator == an();
  }
  void increment() { ++m_iterator; }
  Base m_iterator;
};
template <typename> struct result_of;
template <typename df, typename... Args> struct result_of<df(Args...)> {
  typedef decltype(df()(bf<Args>()...)) h;
};
namespace iterators {
template <class> class transform_iterator;
template <class UnaryFunc, class bo> struct transform_iterator_base {
  typedef iterator_adaptor<
      transform_iterator<UnaryFunc>, bo, UnaryFunc, int,
      typename ia_dflt_help<int, result_of<UnaryFunc(typename bo::ah)>>::h>
      h;
};
template <typename> class zip_iterator;
template <class UnaryFunc>
struct transform_iterator
    : transform_iterator_base<UnaryFunc, zip_iterator<int>>::h {
  void dereference() { m_f(*this->an()); }
  UnaryFunc m_f;
};
template <class UnaryFunc>
transform_iterator<UnaryFunc> make_transform_iterator(zip_iterator<int>,
                                                      UnaryFunc);
} // namespace iterators
namespace tuples {
template <class, class> struct cons;
template <class = int, class = int, class = int, class = int, class = int,
          class = int, class = int, class = int, class = int, class = int>
class tuple;
template <class aq> struct access_traits {
  typedef const aq &const_type;
  typedef aq &non_const_type;
};
template <long, class HT, class TT>
access_traits<HT>::const_type get(cons<HT, TT>);
template <class aq> struct wrap_non_storeable_type {
  typedef aq h;
};
template <class HT, class TT> struct cons {
  typedef HT head_type;
  typedef TT tail_type;
  typedef wrap_non_storeable_type<head_type>::h stored_head_type;
  stored_head_type head;
  tail_type tail;
  access_traits<stored_head_type>::non_const_type get_head() { return head; }
  access_traits<tail_type>::non_const_type get_tail() { return tail; }
  access_traits<stored_head_type>::const_type get_head() const { return head; }
  access_traits<tail_type>::const_type get_tail() const { return tail; }
};
template <class T0, class bg, class, class, class, class, class, class, class,
          class>
struct map_tuple_to_cons {
  typedef cons<T0, typename map_tuple_to_cons<bg, int, int, int, int, int, int,
                                              int, int, int>::h>
      h;
};
template <>
struct map_tuple_to_cons<int, int, int, int, int, int, int, int, int, int> {
  typedef int h;
};
template <class T0, class bg, class, class, class, class, class, class, class,
          class>
struct tuple
    : map_tuple_to_cons<T0, bg, int, int, int, int, int, int, int, int>::h {};
} // namespace tuples
using tuples::tuple;
} // namespace av
template <class R_> struct aa {
  ak<typename R_::FT, 3> an;
};
template <typename K> struct Compare_xy_2 {
  typedef K::Point_2 Point_2;
  void operator()(Point_2, Point_2);
};
template <typename K_, typename FT_> struct Cartesian_base {
  typedef FT_ FT;
  typedef m Point_2;
  typedef aa<K_> Line_2;
};
template <typename K_base> struct Type_equality_wrapper : K_base {};
template <typename FT_, typename Kernel_>
struct Cartesian_base_no_ref_count : Cartesian_base<Kernel_, FT_> {};
template <typename FT_>
struct j : Type_equality_wrapper<Cartesian_base_no_ref_count<FT_, j<FT_>>> {};
template <class C2E> struct Filtered_predicate {
  C2E c2e;
  Compare_xy_2<j<double>> ep;
  template <typename... Args> void operator()(Args... r) { ep(c2e(r)...); }
};
struct Mpzf {
  ~Mpzf();
};
struct Cartesian_converter {
  j<Mpzf>::Line_2 operator()(Type_equality_wrapper<j<double>>::Line_2);
};
namespace av {
namespace aw {
template <typename> struct begin_impl;
template <typename> struct end_impl;
template <typename> struct sequence_tag;
template <typename Sequence> struct begin {
  typedef sequence_tag<Sequence>::h tag_;
  typedef begin_impl<tag_>::template apply<Sequence>::h h;
};
template <typename Sequence> struct ab {
  typedef sequence_tag<Sequence>::h tag_;
  typedef end_impl<tag_>::template apply<Sequence>::h h;
};
const long ax = -1;
template <int, typename, typename, typename, typename> struct fold_impl;
template <typename First, typename Last, typename State, typename ForwardOp>
struct fold_impl<-1, First, Last, State, ForwardOp>
    : fold_impl<-1, typename bh<First>::h, Last,
                typename apply2<ForwardOp, State, typename First::h>::h,
                ForwardOp> {};
template <typename Last, typename State, typename ForwardOp>
struct fold_impl<-1, Last, Last, State, ForwardOp> {
  typedef State state;
};
template <typename Sequence, typename State, typename ForwardOp> struct fold {
  typedef fold_impl<ax, typename begin<Sequence>::h, typename ab<Sequence>::h,
                    State, ForwardOp>::state h;
};
template <typename> struct push_back_impl;
template <typename Sequence = int, typename aq = int>
struct push_back
    : push_back_impl<typename sequence_tag<Sequence>::h>::apply<Sequence, aq> {
};
struct has_push_back {
  static const bool ax = sizeof(0);
};
template <> struct push_back<> {
  template <typename bg, typename bj> struct apply : push_back<bg, bj> {};
};
template <typename Sequence, typename Operation> struct inserter {
  typedef Sequence state;
  typedef Operation operation;
};
template <typename Sequence>
struct back_inserter : inserter<Sequence, push_back<>> {};
template <typename> struct clear_impl;
template <typename Sequence>
struct clear : clear_impl<typename sequence_tag<Sequence>::h>::apply<Sequence> {
};
template <typename Seq, typename Op, typename In>
struct transform1_impl
    : fold<Seq, typename In::state,
           dg<typename In::operation, arg<1>, dh<typename be<Op>::h, arg<2>>>> {
};
template <typename P1>
struct transform1
    : cg<has_push_back,
         transform1_impl<P1, by<arg<1>>,
                         back_inserter<typename clear<P1>::h>>>::h {};
template <typename Seq1> struct transform {
  typedef bs<br<bb<true>>, transform1<Seq1>>::h h;
};
} // namespace aw
} // namespace av
template <typename, typename, typename> struct Type_mapper_impl;
template <typename K1, typename K2>
struct Type_mapper_impl<typename K1::Line_2, K1, K2> {
  typedef K2::Line_2 h;
};
auto call_once___callable = [] {};
struct once_flag {
  struct _Prepare_execution;
} __thread *__once_callable;
struct once_flag::_Prepare_execution {
  template <typename _Callable> _Prepare_execution(_Callable) {
    __once_callable = nullptr;
  }
};
template <typename _Callable> void call_once(_Callable) {
  once_flag::_Prepare_execution __exec(call_once___callable);
}
template <typename ET> auto approx(e<aa<j<int>>, ET> r) { return r.approx(); }
template <typename ET> ET exact(e<m, ET> r) { return r.exact(); }
once_flag once;
template <typename AT_, typename ET> struct Lazy_rep {
  AT_ approx();
  ET exact_unsafe();
  ET exact() {
    call_once(once);
    return exact_unsafe();
  }
};
struct Exact_converter {
  template <typename aq> auto operator()(aq r) { return exact(r); }
};
template <typename AT_, typename ET_> struct e {
  typedef Lazy_rep<AT_, ET_> Self_rep;
  e(Self_rep *);
  auto approx() { return ptr()->approx(); }
  ET_ exact() { return ptr()->exact(); }
  Self_rep *ptr();
};
template <typename LK> struct Lazy_construction {
  auto operator()() {
    return typename Type_mapper_impl<a<k<int>>, typename LK::Approximate_kernel,
                                     LK>::h(0);
  }
};
template <typename, typename>
using Epick_with_filtered_predicates = Type_equality_wrapper<j<double>>;
struct Epic_converter {
  p<Epick_with_filtered_predicates<double, int>::Line_2>
  operator()(j<int>::Line_2);
};
template <typename FP, typename EpicP> struct Static_filtered_predicate {
  FP fp;
  EpicP epicp;
  template <typename A1> void operator()(A1 r) {
    Epic_converter convert;
    auto __trans_tmp_4 = approx(r), aa1 = convert(__trans_tmp_4);
    epicp(aa1.ad);
  }
  template <typename A1, typename A2> void operator()(A1 r, A2 p2) {
    fp(r, p2);
  }
};
Static_filtered_predicate<Filtered_predicate<Exact_converter>, int>
compare_xy_2_object();
Static_filtered_predicate<int, Cartesian_converter> is_vertical_2_object();
struct Lazy_kernel_base {
  typedef j<int> Approximate_kernel;
  typedef e<Approximate_kernel::Line_2, int> Line_2;
};
template <typename, typename> using Epeck_lazy_base = Lazy_kernel_base;
template <typename FT, typename>
using Epeck_lazy_base_with_type_equality =
    Type_equality_wrapper<Epeck_lazy_base<FT, class Epeck>>;
struct Epeck : Epeck_lazy_base_with_type_equality<double, Epeck> {};
struct Construct_x_monotone_curve_2 {
  void operator()(e<m, m> r, e<m, m> p2) {
    Lazy_construction<Epeck> __trans_tmp_9;
    auto line = __trans_tmp_9();
    compare_xy_2_object()(r, p2);
    is_vertical_2_object()(line);
  }
};
Construct_x_monotone_curve_2 construct_curve_2_object();
namespace av {
w last1;
typedef e<m, m> *iterator2_t;
struct join_iterator_union {
  iterator2_t &it2() { return m_it2; }
  e<m, m> &dereference(unsigned r) {
    if (r)
      return *m_it2;
    return *m_it1;
  }
  w m_it1;
  iterator2_t m_it2;
};
struct join_iterator : iterator_facade<join_iterator, int, int, e<m, m> &> {
  w __trans_tmp_24;
  void increment() {
    if (m_section)
      ;
    else if (__trans_tmp_24 == last1)
      m_it.it2() = 0;
  }
  ah dereference() { return m_it.dereference(m_section); }
  bool equal(join_iterator) const { return m_section; }
  int m_section;
  join_iterator_union m_it;
};
} // namespace av
template <typename InputIterator> void construct_polycurve(InputIterator r) {
  InputIterator begin;
  ao.aj(begin, r);
}
struct Polycurve_2 {
  template <typename InputIterator>
  Polycurve_2(InputIterator, InputIterator p2) {
    construct_polycurve(p2);
  }
};
struct Arr_polycurve_traits_2 {
  struct Construct_curve_2 {
    template <typename ForwardIterator>
    void operator()(ForwardIterator r, ForwardIterator p2) {
      Polycurve_2(r, p2);
    }
  };
};
namespace av {
namespace fusion {
namespace traits {
template <typename> struct tag_of;
template <class T0, class bg, class bj, class ay, class az, class bl, class T6,
          class T7, class T8, class T9>
struct tag_of<tuple<T0, bg, bj, ay, az, bl, T6, T7, T8, T9>> {
  typedef int h;
};
template <class Head, class Tail> struct tag_of<tuples::cons<Head, Tail>> {
  typedef int h;
};
} // namespace traits
} // namespace fusion
namespace aw {
template <class T0, class bg, class bj, class ay, class az, class bl, class T6,
          class T7, class T8, class T9>
struct sequence_tag<tuple<T0, bg, bj, ay, az, bl, T6, T7, T8, T9>> {
  typedef int h;
};
template <class Head, class Tail>
struct sequence_tag<tuples::cons<Head, Tail>> {
  typedef int h;
};
} // namespace aw
namespace fusion {
namespace detail {
template <typename Sequence> struct tag_of_impl {
  typedef Sequence::fusion_tag h;
};
} // namespace detail
namespace traits {
template <typename Sequence> struct tag_of : detail::tag_of_impl<Sequence> {};
} // namespace traits
namespace detail {
template <typename aq> struct tag_of : traits::tag_of<typename bm<aq>::h> {};
} // namespace detail
struct iterator_facade_tag;
template <typename> struct next_impl {
  template <typename bo> struct apply : bo::bh<bo> {};
};
namespace result_of {
template <typename bo>
struct bh : next_impl<typename bo::fusion_tag>::apply<bo> {};
} // namespace result_of
template <typename bo> result_of::bh<bo>::h bh(bo r) {
  return result_of::bh<bo>::call(r);
}
template <typename> struct equal_to_impl {
  template <typename I1, typename I2>
  struct apply : ae<typename bk<I1>::h, typename bk<I2>::h> {};
};
template <> struct equal_to_impl<iterator_facade_tag> {
  template <typename, typename, typename, typename> struct dispatch;
  template <typename It1, typename It2, typename dn>
  struct dispatch<It1, It2, dn, dn> : It1::equal_to<It1, It2> {};
  template <typename It1, typename It2>
  struct apply
      : dispatch<It1, It2, typename It1::fusion_tag, typename It2::fusion_tag> {
  };
};
namespace result_of {
template <typename I1, typename I2>
struct equal_to : equal_to_impl<typename I1::fusion_tag>::apply<I1, I2> {};
} // namespace result_of
struct iterator_facade {
  typedef iterator_facade_tag fusion_tag;
};
template <typename Cons = int> struct boost_tuple_iterator : iterator_facade {
  typedef Cons cons_type;
  boost_tuple_iterator(Cons &r) : cons(r) {}
  Cons &cons;
  template <typename>
  struct value_of : aw::cf<typename cons_type::head_type> {};
  template <typename bo> struct deref {
    typedef value_of<bo>::h element;
    typedef aw::cg<
        ba<cons_type>, typename tuples::access_traits<element>::const_type,
        typename tuples::access_traits<element>::non_const_type>::h h;
    static h call(bo r) { return r.cons.get_head(); }
  };
  template <typename bo> struct bh {
    typedef cons_type::tail_type tail_type;
    typedef boost_tuple_iterator<
        typename aw::bs<ba<cons_type>, bk<tail_type>, aw::cf<tail_type>>::h>
        h;
    static h call(bo r) { return r.cons.get_tail(); }
  };
  template <typename, typename I2>
  struct equal_to : ae<Cons, typename I2::cf> {};
};
struct boost_tuple_null_iterator : iterator_facade {
  typedef int cf;
  template <typename, typename> struct equal_to : aw::br<ae<int, int>> {};
};
template <> struct boost_tuple_iterator<> : boost_tuple_null_iterator {
  template <typename Cons> boost_tuple_iterator(Cons);
};
template <> struct boost_tuple_iterator<int const> : boost_tuple_null_iterator {
  template <typename Cons> boost_tuple_iterator(Cons) {}
};
template <> struct boost_tuple_iterator<tuple<>> : boost_tuple_null_iterator {};
template <typename> struct begin_impl {
  template <typename Sequence> struct apply {
    typedef boost_tuple_iterator<Sequence> h;
    static h call(Sequence r) { return r; }
  };
};
template <typename> struct end_impl {
  template <typename Sequence> struct apply {
    typedef boost_tuple_iterator<typename aw::cg<ba<Sequence>, int const>::h> h;
  };
};
template <typename> struct value_of_impl {
  template <typename bo> struct apply : bo::value_of<bo> {};
};
namespace result_of {
template <typename bo>
struct value_of : value_of_impl<typename bo::fusion_tag>::apply<bo> {};
} // namespace result_of
template <typename> struct deref_impl {
  template <typename bo> struct apply : bo::deref<bo> {};
};
namespace result_of {
template <typename bo>
struct deref : deref_impl<typename bo::fusion_tag>::apply<bo> {};
} // namespace result_of
template <typename bo> result_of::deref<bo>::h deref(bo r) {
  return result_of::deref<bo>::call(r);
}
template <typename bo> result_of::deref<bo>::h operator*(bo r) {
  return deref(r);
}
namespace detail {
template <typename First, typename Last,
          bool = result_of::equal_to<First, Last>::ax>
struct build_tuple_cons {
  typedef int h;
  static h call(First, Last) { return h(); }
};
template <typename First, typename Last>
struct build_tuple_cons<First, Last, false> {
  typedef build_tuple_cons<typename result_of::bh<First>::h, Last>
      next_build_tuple_cons;
  typedef tuples::cons<typename result_of::value_of<First>::h,
                       typename next_build_tuple_cons::h>
      h;
  static h call(First r, Last p2) {
    typename result_of::value_of<First>::h v = *r;
    return h(v, next_build_tuple_cons::call(bh(r), p2));
  }
};
} // namespace detail
namespace result_of {
template <typename Sequence>
struct begin
    : begin_impl<typename detail::tag_of<Sequence>::h>::apply<Sequence> {};
template <typename Sequence>
struct ab : end_impl<typename detail::tag_of<Sequence>::h>::apply<Sequence> {};
} // namespace result_of
namespace traits {
struct is_view : bb<0> {};
} // namespace traits
} // namespace fusion
namespace aw {
template <typename bo> struct fusion_iterator {
  typedef fusion::result_of::value_of<bo>::h h;
};
template <typename bo> struct bh<fusion_iterator<bo>> {
  typedef fusion_iterator<typename fusion::result_of::bh<bo>::h> h;
};
template <> struct begin_impl<int> {
  template <typename Sequence> struct apply {
    typedef fusion_iterator<typename fusion::result_of::begin<Sequence>::h> h;
  };
};
template <> struct end_impl<int> {
  template <typename Sequence> struct apply {
    typedef fusion_iterator<typename fusion::result_of::ab<Sequence>::h> h;
  };
};
} // namespace aw
namespace fusion {
template <> struct next_impl<int> {
  template <typename bo> struct apply {
    typedef aw::cg<
        result_of::equal_to<typename result_of::bh<typename bo::first_type>::h,
                            typename bo::last_type>,
        typename bo::concat_type>::h h;
  };
};
template <> struct value_of_impl<int> {
  template <typename bo> struct apply {
    typedef result_of::value_of<typename bo::first_type>::h h;
  };
};
template <typename First, typename Last, typename Concat>
struct joint_view_iterator {
  typedef First first_type;
  typedef Last last_type;
  typedef Concat concat_type;
  typedef int fusion_tag;
};
struct joint_view_tag;
template <> struct begin_impl<joint_view_tag> {
  template <typename Sequence> struct apply {
    typedef Sequence::first_type first_type;
    typedef Sequence::last_type last_type;
    typedef Sequence::concat_type concat_type;
    typedef aw::cg<result_of::equal_to<first_type, last_type>, concat_type,
                   joint_view_iterator<first_type, last_type, concat_type>>::h
        h;
  };
};
template <> struct end_impl<joint_view_tag> {
  template <typename Sequence> struct apply {
    typedef Sequence::concat_last_type h;
  };
};
template <typename Sequence1, typename Sequence2> struct joint_view {
  typedef joint_view_tag fusion_tag;
  typedef result_of::begin<Sequence1>::h first_type;
  typedef result_of::ab<Sequence1>::h last_type;
  typedef result_of::begin<Sequence2>::h concat_type;
  typedef result_of::ab<Sequence2>::h concat_last_type;
};
struct single_view_iterator_tag;
template <typename SingleView, typename Pos> struct single_view_iterator {
  typedef single_view_iterator_tag fusion_tag;
  typedef SingleView::value_type value_type;
  typedef Pos position;
  typedef SingleView single_view_type;
};
template <> struct next_impl<single_view_iterator_tag> {
  template <typename bo> struct apply {
    typedef single_view_iterator<typename bo::single_view_type,
                                 typename aw::bh<typename bo::position>::h>
        h;
  };
};
template <> struct value_of_impl<single_view_iterator_tag> {
  template <typename bo> struct apply {
    typedef bo::value_type h;
  };
};
struct single_view_tag;
template <> struct begin_impl<single_view_tag> {
  template <typename Sequence> struct apply {
    typedef single_view_iterator<Sequence, aw::bd<0>> h;
  };
};
template <> struct end_impl<single_view_tag> {
  template <typename Sequence> struct apply {
    typedef single_view_iterator<Sequence, aw::bd<1>> h;
  };
};
template <typename aq> struct single_view {
  typedef single_view_tag fusion_tag;
  typedef aq value_type;
};
namespace result_of {
template <typename Sequence, typename aq> struct push_back {
  typedef joint_view<Sequence, single_view<aq>> h;
};
} // namespace result_of
template <typename Sequence>
bu<result_of::begin<Sequence>>::h begin(Sequence r) {
  return result_of::begin<Sequence>::call(r);
}
template <typename Sequence> struct apply {
  typedef detail::build_tuple_cons<typename result_of::begin<Sequence>::h,
                                   typename result_of::ab<Sequence>::h>
      build_tuple_cons;
  typedef build_tuple_cons::h h;
  static h call(Sequence r) {
    typename result_of::begin<Sequence>::h __trans_tmp_6 = begin(r);
    typename result_of::ab<Sequence>::h __trans_tmp_7(r);
    return build_tuple_cons::call(__trans_tmp_6, __trans_tmp_7);
  }
};
namespace detail {
template <typename First, typename Last, typename df>
void for_each_linear(First, Last, df, bb<true>) {}
template <typename First, typename Last, typename df>
void for_each_linear(First r, Last p2, df p3, bb<false>) {
  p3(*r);
  for_each_linear(
      bh(r), p2, p3,
      result_of::equal_to<typename result_of::bh<First>::h, Last>());
}
template <typename Sequence, typename df, typename dn>
void for_each_dispatch(Sequence &r, df p2, dn) {
  typename result_of::begin<Sequence>::h __trans_tmp_2 = r;
  typename result_of::ab<Sequence>::h __trans_tmp_3 = 0;
  for_each_linear(__trans_tmp_2, __trans_tmp_3, p2,
                  result_of::equal_to<typename result_of::begin<Sequence>::h,
                                      typename result_of::ab<Sequence>::h>());
}
template <typename Sequence, typename df> void for_each(Sequence &r, df p2) {
  for_each_dispatch(r, p2, int());
}
} // namespace detail
template <typename df>
void for_each(tuple<join_iterator, join_iterator> &r, df p2) {
  detail::for_each(r, p2);
}
struct transform_view_iterator_tag;
template <> struct deref_impl<transform_view_iterator_tag> {
  template <typename bo> struct apply {
    typedef result_of::deref<typename bo::first_type>::h value_type;
    typedef bo::transform_type df;
    typedef typename result_of<df(value_type)>::h h;
    static h call(bo r) { return r.f(*r.ad); }
  };
};
template <typename First, typename df> struct transform_view_iterator {
  typedef transform_view_iterator_tag fusion_tag;
  typedef First first_type;
  typedef df transform_type;
  first_type ad;
  transform_type f;
};
template <> struct next_impl<transform_view_iterator_tag> {
  template <typename bo> struct apply {
    typedef transform_view_iterator<
        typename result_of::bh<typename bo::first_type>::h,
        typename bo::transform_type>
        h;
    static h call(bo r) { return h(bh(r.ad)); }
  };
};
template <> struct value_of_impl<transform_view_iterator_tag> {
  template <typename bo> struct apply {
    typedef av::result_of<typename bo::transform_type(
        typename result_of::value_of<typename bo::first_type>::h)>::h h;
  };
};
struct transform_view_tag;
template <> struct begin_impl<transform_view_tag> {
  template <typename Sequence> struct apply {
    typedef transform_view_iterator<typename Sequence::first_type,
                                    typename Sequence::transform_type>
        h;
    static h call(Sequence r) { return h(r.ad()); }
  };
};
template <> struct end_impl<transform_view_tag> {
  template <typename Sequence> struct apply {
    typedef transform_view_iterator<typename Sequence::last_type,
                                    typename Sequence::transform_type>
        h;
  };
};
} // namespace fusion
namespace aw {
template <> struct clear_impl<int> {
  template <typename> struct apply {
    typedef tuple<> h;
  };
};
} // namespace aw
namespace fusion {
namespace result_of {
template <typename Sequence> struct convert {
  typedef apply<Sequence> gen;
  typedef gen::h h;
};
} // namespace result_of
template <typename, typename Sequence>
result_of::convert<Sequence>::h convert(Sequence r) {
  typedef typename result_of::convert<Sequence>::gen gen;
  return gen::call(r);
}
} // namespace fusion
namespace aw {
template <> struct push_back_impl<int> {
  template <typename Sequence, typename aq> struct apply {
    typedef fusion::result_of::convert<
        typename fusion::result_of::push_back<Sequence, aq>::h>::h h;
  };
};
} // namespace aw
namespace fusion {
template <typename, typename df> struct transform_view {
  typedef transform_view_tag fusion_tag;
  typedef result_of::begin<const tuple<join_iterator, join_iterator>>::h
      first_type;
  typedef result_of::ab<const tuple<>>::h last_type;
  typedef df transform_type;
  first_type ad() { return seq; }
  aw::cg<traits::is_view, int, const tuple<join_iterator, join_iterator> &>::h
      seq;
};
namespace result_of {
template <typename, typename df> struct transform {
  typedef transform_view<const tuple<join_iterator, join_iterator>, df> h;
};
} // namespace result_of
template <typename df>
result_of::transform<int, df>::h
transform(const tuple<join_iterator, join_iterator> &r, df) {
  return transform_view<const tuple<join_iterator, join_iterator>, df>(r);
}
namespace detail {
struct sequence_equal_to {
  template <typename I1, typename I2> static bool call(I1, I2, bb<true>);
  template <typename I1, typename I2> static bool call(I1 r, I2 p2, bb<false>) {
    return *r == *p2 && call(bh(r), bh(p2));
  }
  template <typename I1, typename I2> static bool call(I1 r, I2 p2) {
    result_of::equal_to<I1, result_of::ab<tuple<>>::h> eq;
    return call(r, p2, eq);
  }
};
} // namespace detail
template <typename Seq2>
bool equal_to(const tuple<join_iterator, join_iterator> &r, Seq2 p2) {
  boost_tuple_iterator __trans_tmp_27 = r;
  return detail::sequence_equal_to::call(__trans_tmp_27, begin(p2));
}
} // namespace fusion
namespace iterators {
struct increment_iterator {
  template <typename bo> void operator()(bo &r) { ++r; }
};
struct dereference_iterator {
  template <typename> struct result;
  template <typename This, typename bo> struct result<This(bo)> {
    typedef by<bo>::h h;
  };
  template <typename bo> result<dereference_iterator(bo)>::h operator()(bo r) {
    return *r;
  }
};
struct minimum_traversal_category_in_iterator_tuple;
typedef aw::transform<tuple<join_iterator, join_iterator>>::h ah;
static ah call(fusion::transform_view<const tuple<join_iterator, join_iterator>,
                                      dereference_iterator>
                   r) {
  return convert < ah >> (r);
}
template <typename>
struct zip_iterator
    : iterator_facade<zip_iterator<int>, ah,
                      minimum_traversal_category_in_iterator_tuple, ah> {
  const tuple<join_iterator, join_iterator> &get_iterator_tuple() const {
    return m_iterator_tuple;
  }
  ah dereference() {
    const tuple<join_iterator, join_iterator> &__trans_tmp_21 =
        get_iterator_tuple();
    fusion::transform_view __trans_tmp_26 =
        fusion::transform(__trans_tmp_21, dereference_iterator());
    return call(__trans_tmp_26);
  }
  template <typename OtherIteratorTuple> bool equal(OtherIteratorTuple) const {
    const tuple<join_iterator, join_iterator> &__trans_tmp_24 =
        get_iterator_tuple();
    tuple<join_iterator, join_iterator> __trans_tmp_25;
    return fusion::equal_to(__trans_tmp_24, __trans_tmp_25);
  }
  void increment() { fusion::for_each(m_iterator_tuple, increment_iterator()); }
  tuple<join_iterator, join_iterator> m_iterator_tuple;
};
} // namespace iterators
using iterators::zip_iterator;
} // namespace av
struct Construct_curve_2 {
  template <typename ForwardIterator>
  void operator()(ForwardIterator r, ForwardIterator p2) const {
    constructor_impl(r, p2, int());
  }
  void operator()(int) {
    av::join_iterator __trans_tmp_11, __trans_tmp_18;
    operator()(__trans_tmp_18, __trans_tmp_11);
  }
  template <typename ForwardIterator>
  void constructor_impl(ForwardIterator r, ForwardIterator p2, b<false>) const {
    Arr_polycurve_traits_2::Construct_curve_2()(r, p2);
  }
  void constructor_impl(av::join_iterator, av::join_iterator, b<true>) const {
    auto point_pair_to_segment = [](av::zip_iterator<av::tuple<>>::ah t) {
      construct_curve_2_object()(0, get<1>(t));
    };
    av::zip_iterator<int> __trans_tmp_20, __trans_tmp_22;
    operator()(make_transform_iterator(__trans_tmp_22, point_pair_to_segment),
               make_transform_iterator(__trans_tmp_20, point_pair_to_segment));
  }
};
int __trans_tmp_33___trans_tmp_16;
int
__trans_tmp_33()
{
  Construct_curve_2 __trans_tmp_10;
  __trans_tmp_10(__trans_tmp_33___trans_tmp_16);
}

// { dg-final { scan-assembler-times "call\[ \t\]__tls_get_addr@PLT" 1 { target { ! ia32 } } } }