| 1 |
/* { dg-do compile } */ |
| 2 |
/* { dg-options "-O3 -mcpu=neoverse-v2 --param=aarch64-autovec-preference=sve-only -w" } */ |
| 3 |
|
| 4 |
namespace a { |
| 5 |
typedef long unsigned b; |
| 6 |
typedef int c; |
| 7 |
template <bool, typename d> struct e { using f = d; }; |
| 8 |
template <bool g, typename d = void> using h = typename e<g, d>::f; |
| 9 |
template <typename aa, typename, template <typename> class> struct i { |
| 10 |
using f = aa; |
| 11 |
}; |
| 12 |
template <typename aa, template <typename> class j> using k = i<aa, void, j>; |
| 13 |
template <typename aa, template <typename> class j> |
| 14 |
using l = typename k<aa, j>::f; |
| 15 |
} // namespace a |
| 16 |
inline void *operator new(a::b, void *ab) { return ab; } |
| 17 |
namespace a { |
| 18 |
template <typename> class ac { |
| 19 |
public: |
| 20 |
typedef b m; |
| 21 |
template <typename ad, typename... n> void ae(ad *ab, n... w) { |
| 22 |
new (ab) ad(w...); |
| 23 |
} |
| 24 |
}; |
| 25 |
template <typename d> using x = ac<d>; |
| 26 |
template <typename d> class af : public x<d> { |
| 27 |
public: |
| 28 |
typedef d o; |
| 29 |
template <typename> struct ag { typedef af ah; }; |
| 30 |
}; |
| 31 |
struct ai {}; |
| 32 |
struct aj : ai {}; |
| 33 |
struct ak : aj {}; |
| 34 |
template <typename> struct al; |
| 35 |
template <typename d> struct al<d *> { |
| 36 |
typedef ak an; |
| 37 |
typedef c ao; |
| 38 |
typedef d ap; |
| 39 |
}; |
| 40 |
template <typename aq> typename aq ::an ar(aq) { return typename aq ::an(); } |
| 41 |
template <typename as> typename as ::ao at(as au, as av, ak) { return av - au; } |
| 42 |
template <typename aw> typename aw ::ao ax(aw au, aw av) { |
| 43 |
return at(au, av, ar(au)); |
| 44 |
} |
| 45 |
template <typename> struct ay { typedef c ao; }; |
| 46 |
} // namespace a |
| 47 |
namespace az { |
| 48 |
template <typename am, typename> class ba { |
| 49 |
am bb; |
| 50 |
typedef a::al<am> bc; |
| 51 |
|
| 52 |
public: |
| 53 |
typedef typename bc::an an; |
| 54 |
typedef typename bc::ao ao; |
| 55 |
typedef typename bc::ap ap; |
| 56 |
ba(am bd) : bb(bd) {} |
| 57 |
ap operator*() { return *bb; } |
| 58 |
ba operator++() { |
| 59 |
++bb; |
| 60 |
return *this; |
| 61 |
} |
| 62 |
am base() { return bb; } |
| 63 |
}; |
| 64 |
template <typename be, typename bf, typename bg> |
| 65 |
bool operator!=(ba<be, bg> bh, ba<bf, bg> p) { |
| 66 |
return bh.base() != p.base(); |
| 67 |
} |
| 68 |
template <typename be, typename bf, typename bg> |
| 69 |
auto operator-(ba<be, bg> bh, ba<bf, bg> p) { |
| 70 |
return bh.base() - p.base(); |
| 71 |
} |
| 72 |
} // namespace az |
| 73 |
namespace a { |
| 74 |
struct bi { |
| 75 |
template <typename d, typename> struct bj { |
| 76 |
using f = typename d::ag<d>::ah; |
| 77 |
}; |
| 78 |
template <typename> using bk = b; |
| 79 |
template <typename...> static constexpr bool bl = false; |
| 80 |
template <typename, typename> static constexpr bool bm = bl<>; |
| 81 |
template <typename d, typename... n> static constexpr bool bn = bm<d, n...>; |
| 82 |
}; |
| 83 |
template <typename bo, typename ad> using bp = typename bi::bj<bo, ad>::f; |
| 84 |
template <typename bo> struct bq : bi { |
| 85 |
typedef typename bo::o o; |
| 86 |
using br = l<o *, bk>; |
| 87 |
template <typename, typename bs> struct bt { using f = typename ay<bs>::ao; }; |
| 88 |
template <typename bu, typename> struct bv { using f = typename bu::m; }; |
| 89 |
using ao = typename bt<bo, c>::f; |
| 90 |
using m = typename bv<bo, ao>::f; |
| 91 |
template <typename d> using bw = bp<bo, d>; |
| 92 |
static br allocate(bo, m); |
| 93 |
template <typename d, typename... n> |
| 94 |
static h<bn<bo, d>> ae(bo ci, d ab, n... w) { |
| 95 |
ci.ae(ab, w...); |
| 96 |
} |
| 97 |
}; |
| 98 |
template <typename d> struct bx { |
| 99 |
static bool by(d &bz) try { d(bz.begin(), bz.ca(), bz.cb()); } catch (...) { |
| 100 |
} |
| 101 |
}; |
| 102 |
} // namespace a |
| 103 |
namespace az { |
| 104 |
template <typename bo> struct cc : a::bq<bo> { |
| 105 |
typedef a::bq<bo> q; |
| 106 |
template <typename d> struct ag { typedef typename q::bw<d> ah; }; |
| 107 |
}; |
| 108 |
} // namespace az |
| 109 |
enum cd {}; |
| 110 |
using ce = double; |
| 111 |
namespace a { |
| 112 |
template <typename aw, typename cf, typename cg, typename ch> |
| 113 |
cg cj(aw au, cf av, cg ck, ch cl) { |
| 114 |
typedef az::cc<ch> cx; |
| 115 |
for (; au != av; ++au, ++ck) |
| 116 |
cx::ae(cl, ck, *au); |
| 117 |
} |
| 118 |
template <typename d, typename bo> struct cm { |
| 119 |
typedef typename az::cc<bo>::ag<d>::ah cn; |
| 120 |
typedef typename az::cc<cn>::br br; |
| 121 |
struct co { |
| 122 |
br db; |
| 123 |
br cp; |
| 124 |
}; |
| 125 |
struct cq : cn, co { |
| 126 |
cq(cn) {} |
| 127 |
} typedef cr; |
| 128 |
cn cs(); |
| 129 |
cr cb() noexcept; |
| 130 |
cm(cr ci) : ct(ci) {} |
| 131 |
cq ct; |
| 132 |
br cu(b cv) { |
| 133 |
typedef az::cc<cn> cw; |
| 134 |
return cv ? cw::allocate(ct, cv) : c(); |
| 135 |
} |
| 136 |
}; |
| 137 |
template <typename d, typename bo = af<d>> class cy : cm<d, bo> { |
| 138 |
typedef cm<d, bo> cz; |
| 139 |
|
| 140 |
public: |
| 141 |
typedef typename cz::br br; |
| 142 |
typedef az::ba<br, cy> da; |
| 143 |
typedef b m; |
| 144 |
typedef bo cr; |
| 145 |
cz::cs; |
| 146 |
template <typename aw> cy(aw au, aw av, cr ci) : cz(ci) { |
| 147 |
dg(au, av, ar(au)); |
| 148 |
} |
| 149 |
cz::cb; |
| 150 |
da begin() { return this->ct.db; } |
| 151 |
da ca() { return this->ct.cp; } |
| 152 |
void r() { s(); } |
| 153 |
void clear() { t(this->ct.db); } |
| 154 |
template <typename cg> void dg(cg au, cg av, ai) { y(au, av, ax(au, av)); } |
| 155 |
template <typename am, typename cf> void y(am au, cf av, m cv) { |
| 156 |
br z = this->cu(dc(cv, cs())); |
| 157 |
cj(au, av, z, cs()); |
| 158 |
} |
| 159 |
bool s(); |
| 160 |
m dc(m cv, cr) { return cv; } |
| 161 |
void t(br dd) { |
| 162 |
if (this->ct.cp - dd) |
| 163 |
this->ct.cp = dd; |
| 164 |
} |
| 165 |
}; |
| 166 |
template <typename d, typename bo> bool cy<d, bo>::s() { bx<cy>::by(*this); } |
| 167 |
namespace basic { |
| 168 |
class u { |
| 169 |
using de = ce; |
| 170 |
void v(cd, b); |
| 171 |
cy<de> df; |
| 172 |
}; |
| 173 |
void u::v(cd, b) { |
| 174 |
df.clear(); |
| 175 |
df.r(); |
| 176 |
} |
| 177 |
} // namespace basic |
| 178 |
} // namespace a |