/* { dg-do compile } */ /* { dg-options "-O3 -mcpu=neoverse-v2 --param=aarch64-autovec-preference=sve-only -w" } */ namespace a { typedef long unsigned b; typedef int c; template struct e { using f = d; }; template using h = typename e::f; template class> struct i { using f = aa; }; template class j> using k = i; template class j> using l = typename k::f; } // namespace a inline void *operator new(a::b, void *ab) { return ab; } namespace a { template class ac { public: typedef b m; template void ae(ad *ab, n... w) { new (ab) ad(w...); } }; template using x = ac; template class af : public x { public: typedef d o; template struct ag { typedef af ah; }; }; struct ai {}; struct aj : ai {}; struct ak : aj {}; template struct al; template struct al { typedef ak an; typedef c ao; typedef d ap; }; template typename aq ::an ar(aq) { return typename aq ::an(); } template typename as ::ao at(as au, as av, ak) { return av - au; } template typename aw ::ao ax(aw au, aw av) { return at(au, av, ar(au)); } template struct ay { typedef c ao; }; } // namespace a namespace az { template class ba { am bb; typedef a::al bc; public: typedef typename bc::an an; typedef typename bc::ao ao; typedef typename bc::ap ap; ba(am bd) : bb(bd) {} ap operator*() { return *bb; } ba operator++() { ++bb; return *this; } am base() { return bb; } }; template bool operator!=(ba bh, ba p) { return bh.base() != p.base(); } template auto operator-(ba bh, ba p) { return bh.base() - p.base(); } } // namespace az namespace a { struct bi { template struct bj { using f = typename d::ag::ah; }; template using bk = b; template static constexpr bool bl = false; template static constexpr bool bm = bl<>; template static constexpr bool bn = bm; }; template using bp = typename bi::bj::f; template struct bq : bi { typedef typename bo::o o; using br = l; template struct bt { using f = typename ay::ao; }; template struct bv { using f = typename bu::m; }; using ao = typename bt::f; using m = typename bv::f; template using bw = bp; static br allocate(bo, m); template static h> ae(bo ci, d ab, n... w) { ci.ae(ab, w...); } }; template struct bx { static bool by(d &bz) try { d(bz.begin(), bz.ca(), bz.cb()); } catch (...) { } }; } // namespace a namespace az { template struct cc : a::bq { typedef a::bq q; template struct ag { typedef typename q::bw ah; }; }; } // namespace az enum cd {}; using ce = double; namespace a { template cg cj(aw au, cf av, cg ck, ch cl) { typedef az::cc cx; for (; au != av; ++au, ++ck) cx::ae(cl, ck, *au); } template struct cm { typedef typename az::cc::ag::ah cn; typedef typename az::cc::br br; struct co { br db; br cp; }; struct cq : cn, co { cq(cn) {} } typedef cr; cn cs(); cr cb() noexcept; cm(cr ci) : ct(ci) {} cq ct; br cu(b cv) { typedef az::cc cw; return cv ? cw::allocate(ct, cv) : c(); } }; template > class cy : cm { typedef cm cz; public: typedef typename cz::br br; typedef az::ba da; typedef b m; typedef bo cr; cz::cs; template cy(aw au, aw av, cr ci) : cz(ci) { dg(au, av, ar(au)); } cz::cb; da begin() { return this->ct.db; } da ca() { return this->ct.cp; } void r() { s(); } void clear() { t(this->ct.db); } template void dg(cg au, cg av, ai) { y(au, av, ax(au, av)); } template void y(am au, cf av, m cv) { br z = this->cu(dc(cv, cs())); cj(au, av, z, cs()); } bool s(); m dc(m cv, cr) { return cv; } void t(br dd) { if (this->ct.cp - dd) this->ct.cp = dd; } }; template bool cy::s() { bx::by(*this); } namespace basic { class u { using de = ce; void v(cd, b); cy df; }; void u::v(cd, b) { df.clear(); df.r(); } } // namespace basic } // namespace a