1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
|
// PR c++/87539
// { dg-do compile { target c++11 } }
// { dg-options "-Os" }
namespace a {
template <typename b, typename = b, typename = int> class c;
class exception {};
template <typename d> struct e { d f; };
struct g { g(); g(const g &); };
}
template <class, class, class = int> class h;
template <typename, typename> struct i;
template <int j> struct aa { static const int k = j; };
struct ac { typedef a::e<int> l; };
struct ad;
template <int, typename m, typename> struct ae { typedef m l; };
template <typename m, typename n> struct ae<false, m, n> { typedef n l; };
template <typename m, typename n, typename p> struct o {
typedef typename ae<m::k, n, p>::l l;
};
struct af { af(char *); };
template <typename> struct ag { ag(a::g = a::g()) {} };
template <typename ah, typename ai, typename aj, typename al>
struct i<a::c<ah, ai, aj>, al> { typedef ag<al> l; };
namespace ak {
template <typename am, typename an, typename ao> struct ap {
typedef typename o<am, an, ao>::l ::l l;
};
template <typename = ad> struct aq { typedef ad l; };
}
template <typename ar> struct as {
typedef char at;
template <typename au, typename> static decltype(au(), at()) av(int);
template <typename, typename> static int av(...);
static const bool k = sizeof(av<ar, int>(0)) == 1;
};
template <typename ar> struct aw { static const bool k = as<ar>::k; };
template <class ar> struct ax { typedef aw<ar> l; };
template <typename ar> struct ay { typedef typename ax<ar>::l l; };
template <typename ar> struct az : ay<ar>::l {};
template <class ar, class> struct ba : aa<az<ar>::k> {};
template <class> struct bb : ak::ap<ba<int, int>, ak::aq<>, int> {};
template <typename> struct q : ba<bb<int>::l, int> {};
template <class, class, bool> class r;
template <class s, class t> struct r<s, t, false> {
s operator*();
s operator++();
};
template <class, class, class, class, class>
class bc : public r<a::e<h<int, int>>, int, q<int>::k> {};
template <class bd, class be, class bf, class u, class v, class bg, class w,
class x, class bh, class bi>
int operator!=(bc<bd, be, bf, u, v>, bc<bg, w, x, bh, bi>);
template <class, class, class> struct h {
typedef af bl;
bc<int, int, int, ak::ap<aa<false>, int, ac>::l, int> begin();
bc<int, int, int, ak::ap<aa<false>, int, ac>::l, int> end();
template <class bm> bm bn() const;
template <class> int bo() const;
template <class bm> int bx(const bl &, const bm &) const;
template <class> int bp(const bl &) const;
};
template <class bq, class br, class am>
template <class bm>
bm h<bq, br, am>::bn() const { typename i<a::c<int>, bm>::l(); return bm(); }
template <class bq, class br, class am>
template <class>
int h<bq, br, am>::bo() const { i<a::c<int>, int>::l(); bn<int>(); return 0; }
template <class bq, class br, class am>
template <class bm>
int h<bq, br, am>::bx(const bl &bs, const bm &) const { bp<int>(bs); return 0; }
template <class bq, class br, class am>
template <class>
int h<bq, br, am>::bp(const bl &) const { bo<int>(); return 0; }
char bt[] = "";
void
d()
{
h<int, int> bu;
for (auto bv : bu)
try {
bv.f.bx(bt, 0);
} catch (a::exception) {
}
}
|
