URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [g++.dg/] [cpp0x/] [overload.C] - Blame information for rev 774

Go to most recent revision | Details | Compare with Previous | View Log


// { dg-options "--std=c++0x" }
// { dg-do link }
// Generated by overload.py
 
template
inline _Tp&&
movel(_Tp& __t)
{ return static_cast<_Tp&&>(__t); }
 
struct S{};
 
S l;                             // lvalue (l)
S const cl = l;                  // const lvalue (cl)
S r() { return l; }              // rvalue (r)
S const cr() { return l; }       // const rvalue (cr)
S & nl = l;                      // named lvalue reference (nl)
S const & ncl = l;               // named const lvalue reference (ncl)
S && nr = movel(l);              // named rvalue reference (nr)
S const && ncr = movel(l);       // named const rvalue reference (ncr)
S & ul() { return l; }           // unnamed lvalue reference (ul)
S const & ucl() { return l; }    // unnamed const lvalue reference (ucl)
S && ur() { return movel(l); }   // unnamed rvalue reference (ur)
S const && ucr() { return movel(l); } // unnamed const rvalue reference (ucr)
 
void l0001(const S&&) {}
 
void l0010(S&&) {}
 
void l0011(S&&) {}
void l0011(const S&&);
 
void l0100(const S&) {}
 
void l0101(const S&) {}
void l0101(const S&&);
 
void l0110(const S&) {}
void l0110(S&&);
 
void l0111(const S&) {}
void l0111(S&&);
void l0111(const S&&);
 
void l1000(S&) {}
 
void l1001(S&) {}
void l1001(const S&&);
 
void l1010(S&) {}
void l1010(S&&);
 
void l1011(S&) {}
void l1011(S&&);
void l1011(const S&&);
 
void l1100(S&) {}
void l1100(const S&);
 
void l1101(S&) {}
void l1101(const S&);
void l1101(const S&&);
 
void l1110(S&) {}
void l1110(const S&);
void l1110(S&&);
 
void l1111(S&) {}
void l1111(const S&);
void l1111(S&&);
void l1111(const S&&);
 
void cl0001(const S&&) {}
 
void cl0011(S&&);
void cl0011(const S&&) {}
 
void cl0100(const S&) {}
 
void cl0101(const S&) {}
void cl0101(const S&&);
 
void cl0110(const S&) {}
void cl0110(S&&);
 
void cl0111(const S&) {}
void cl0111(S&&);
void cl0111(const S&&);
 
void cl1001(S&);
void cl1001(const S&&) {}
 
void cl1011(S&);
void cl1011(S&&);
void cl1011(const S&&) {}
 
void cl1100(S&);
void cl1100(const S&) {}
 
void cl1101(S&);
void cl1101(const S&) {}
void cl1101(const S&&);
 
void cl1110(S&);
void cl1110(const S&) {}
void cl1110(S&&);
 
void cl1111(S&);
void cl1111(const S&) {}
void cl1111(S&&);
void cl1111(const S&&);
 
void r0001(const S&&) {}
 
void r0010(S&&) {}
 
void r0011(S&&) {}
void r0011(const S&&);
 
void r0100(const S&) {}
 
void r0101(const S&);
void r0101(const S&&) {}
 
void r0110(const S&);
void r0110(S&&) {}
 
void r0111(const S&);
void r0111(S&&) {}
void r0111(const S&&);
 
void r1001(S&);
void r1001(const S&&) {}
 
void r1010(S&);
void r1010(S&&) {}
 
void r1011(S&);
void r1011(S&&) {}
void r1011(const S&&);
 
void r1100(S&);
void r1100(const S&) {}
 
void r1101(S&);
void r1101(const S&);
void r1101(const S&&) {}
 
void r1110(S&);
void r1110(const S&);
void r1110(S&&) {}
 
void r1111(S&);
void r1111(const S&);
void r1111(S&&) {}
void r1111(const S&&);
 
void cr0001(const S&&) {}
 
void cr0011(S&&);
void cr0011(const S&&) {}
 
void cr0100(const S&) {}
 
void cr0101(const S&);
void cr0101(const S&&) {}
 
void cr0110(const S&) {}
void cr0110(S&&);
 
void cr0111(const S&);
void cr0111(S&&);
void cr0111(const S&&) {}
 
void cr1001(S&);
void cr1001(const S&&) {}
 
void cr1011(S&);
void cr1011(S&&);
void cr1011(const S&&) {}
 
void cr1100(S&);
void cr1100(const S&) {}
 
void cr1101(S&);
void cr1101(const S&);
void cr1101(const S&&) {}
 
void cr1110(S&);
void cr1110(const S&) {}
void cr1110(S&&);
 
void cr1111(S&);
void cr1111(const S&);
void cr1111(S&&);
void cr1111(const S&&) {}
 
void nl0001(const S&&) {}
 
void nl0010(S&&) {}
 
void nl0011(S&&) {}
void nl0011(const S&&);
 
void nl0100(const S&) {}
 
void nl0101(const S&) {}
void nl0101(const S&&);
 
void nl0110(const S&) {}
void nl0110(S&&);
 
void nl0111(const S&) {}
void nl0111(S&&);
void nl0111(const S&&);
 
void nl1000(S&) {}
 
void nl1001(S&) {}
void nl1001(const S&&);
 
void nl1010(S&) {}
void nl1010(S&&);
 
void nl1011(S&) {}
void nl1011(S&&);
void nl1011(const S&&);
 
void nl1100(S&) {}
void nl1100(const S&);
 
void nl1101(S&) {}
void nl1101(const S&);
void nl1101(const S&&);
 
void nl1110(S&) {}
void nl1110(const S&);
void nl1110(S&&);
 
void nl1111(S&) {}
void nl1111(const S&);
void nl1111(S&&);
void nl1111(const S&&);
 
void ncl0001(const S&&) {}
 
void ncl0011(S&&);
void ncl0011(const S&&) {}
 
void ncl0100(const S&) {}
 
void ncl0101(const S&) {}
void ncl0101(const S&&);
 
void ncl0110(const S&) {}
void ncl0110(S&&);
 
void ncl0111(const S&) {}
void ncl0111(S&&);
void ncl0111(const S&&);
 
void ncl1001(S&);
void ncl1001(const S&&) {}
 
void ncl1011(S&);
void ncl1011(S&&);
void ncl1011(const S&&) {}
 
void ncl1100(S&);
void ncl1100(const S&) {}
 
void ncl1101(S&);
void ncl1101(const S&) {}
void ncl1101(const S&&);
 
void ncl1110(S&);
void ncl1110(const S&) {}
void ncl1110(S&&);
 
void ncl1111(S&);
void ncl1111(const S&) {}
void ncl1111(S&&);
void ncl1111(const S&&);
 
void nr0001(const S&&) {}
 
void nr0010(S&&) {}
 
void nr0011(S&&) {}
void nr0011(const S&&);
 
void nr0100(const S&) {}
 
void nr0101(const S&) {}
void nr0101(const S&&);
 
void nr0110(const S&) {}
void nr0110(S&&);
 
void nr0111(const S&) {}
void nr0111(S&&);
void nr0111(const S&&);
 
void nr1000(S&) {}
 
void nr1001(S&) {}
void nr1001(const S&&);
 
void nr1010(S&) {}
void nr1010(S&&);
 
void nr1011(S&) {}
void nr1011(S&&);
void nr1011(const S&&);
 
void nr1100(S&) {}
void nr1100(const S&);
 
void nr1101(S&) {}
void nr1101(const S&);
void nr1101(const S&&);
 
void nr1110(S&) {}
void nr1110(const S&);
void nr1110(S&&);
 
void nr1111(S&) {}
void nr1111(const S&);
void nr1111(S&&);
void nr1111(const S&&);
 
void ncr0001(const S&&) {}
 
void ncr0011(S&&);
void ncr0011(const S&&) {}
 
void ncr0100(const S&) {}
 
void ncr0101(const S&) {}
void ncr0101(const S&&);
 
void ncr0110(const S&) {}
void ncr0110(S&&);
 
void ncr0111(const S&) {}
void ncr0111(S&&);
void ncr0111(const S&&);
 
void ncr1001(S&);
void ncr1001(const S&&) {}
 
void ncr1011(S&);
void ncr1011(S&&);
void ncr1011(const S&&) {}
 
void ncr1100(S&);
void ncr1100(const S&) {}
 
void ncr1101(S&);
void ncr1101(const S&) {}
void ncr1101(const S&&);
 
void ncr1110(S&);
void ncr1110(const S&) {}
void ncr1110(S&&);
 
void ncr1111(S&);
void ncr1111(const S&) {}
void ncr1111(S&&);
void ncr1111(const S&&);
 
void ul0001(const S&&) {}
 
void ul0010(S&&) {}
 
void ul0011(S&&) {}
void ul0011(const S&&);
 
void ul0100(const S&) {}
 
void ul0101(const S&) {}
void ul0101(const S&&);
 
void ul0110(const S&) {}
void ul0110(S&&);
 
void ul0111(const S&) {}
void ul0111(S&&);
void ul0111(const S&&);
 
void ul1000(S&) {}
 
void ul1001(S&) {}
void ul1001(const S&&);
 
void ul1010(S&) {}
void ul1010(S&&);
 
void ul1011(S&) {}
void ul1011(S&&);
void ul1011(const S&&);
 
void ul1100(S&) {}
void ul1100(const S&);
 
void ul1101(S&) {}
void ul1101(const S&);
void ul1101(const S&&);
 
void ul1110(S&) {}
void ul1110(const S&);
void ul1110(S&&);
 
void ul1111(S&) {}
void ul1111(const S&);
void ul1111(S&&);
void ul1111(const S&&);
 
void ucl0001(const S&&) {}
 
void ucl0011(S&&);
void ucl0011(const S&&) {}
 
void ucl0100(const S&) {}
 
void ucl0101(const S&) {}
void ucl0101(const S&&);
 
void ucl0110(const S&) {}
void ucl0110(S&&);
 
void ucl0111(const S&) {}
void ucl0111(S&&);
void ucl0111(const S&&);
 
void ucl1001(S&);
void ucl1001(const S&&) {}
 
void ucl1011(S&);
void ucl1011(S&&);
void ucl1011(const S&&) {}
 
void ucl1100(S&);
void ucl1100(const S&) {}
 
void ucl1101(S&);
void ucl1101(const S&) {}
void ucl1101(const S&&);
 
void ucl1110(S&);
void ucl1110(const S&) {}
void ucl1110(S&&);
 
void ucl1111(S&);
void ucl1111(const S&) {}
void ucl1111(S&&);
void ucl1111(const S&&);
 
void ur0001(const S&&) {}
 
void ur0010(S&&) {}
 
void ur0011(S&&) {}
void ur0011(const S&&);
 
void ur0100(const S&) {}
 
void ur0101(const S&);
void ur0101(const S&&) {}
 
void ur0110(const S&);
void ur0110(S&&) {}
 
void ur0111(const S&);
void ur0111(S&&) {}
void ur0111(const S&&);
 
void ur1001(S&);
void ur1001(const S&&) {}
 
void ur1010(S&);
void ur1010(S&&) {}
 
void ur1011(S&);
void ur1011(S&&) {}
void ur1011(const S&&);
 
void ur1100(S&);
void ur1100(const S&) {}
 
void ur1101(S&);
void ur1101(const S&);
void ur1101(const S&&) {}
 
void ur1110(S&);
void ur1110(const S&);
void ur1110(S&&) {}
 
void ur1111(S&);
void ur1111(const S&);
void ur1111(S&&) {}
void ur1111(const S&&);
 
void ucr0001(const S&&) {}
 
void ucr0011(S&&);
void ucr0011(const S&&) {}
 
void ucr0100(const S&) {}
 
void ucr0101(const S&);
void ucr0101(const S&&) {}
 
void ucr0110(const S&) {}
void ucr0110(S&&);
 
void ucr0111(const S&);
void ucr0111(S&&);
void ucr0111(const S&&) {}
 
void ucr1001(S&);
void ucr1001(const S&&) {}
 
void ucr1011(S&);
void ucr1011(S&&);
void ucr1011(const S&&) {}
 
void ucr1100(S&);
void ucr1100(const S&) {}
 
void ucr1101(S&);
void ucr1101(const S&);
void ucr1101(const S&&) {}
 
void ucr1110(S&);
void ucr1110(const S&) {}
void ucr1110(S&&);
 
void ucr1111(S&);
void ucr1111(const S&);
void ucr1111(S&&);
void ucr1111(const S&&) {}
 
 
int main()
{
  //l0001(l);
  //l0010(l);
  //l0011(l);
  l0100(l);
  l0101(l);
  l0110(l);
  l0111(l);
  l1000(l);
  l1001(l);
  l1010(l);
  l1011(l);
  l1100(l);
  l1101(l);
  l1110(l);
  l1111(l);
  //cl0001(cl);
  //cl0011(cl);
  cl0100(cl);
  cl0101(cl);
  cl0110(cl);
  cl0111(cl);
  //cl1001(cl);
  //cl1011(cl);
  cl1100(cl);
  cl1101(cl);
  cl1110(cl);
  cl1111(cl);
  r0001(r());
  r0010(r());
  r0011(r());
  r0100(r());
  r0101(r());
  r0110(r());
  r0111(r());
  r1001(r());
  r1010(r());
  r1011(r());
  r1100(r());
  r1101(r());
  r1110(r());
  r1111(r());
  cr0001(cr());
  cr0011(cr());
  cr0100(cr());
  cr0101(cr());
  cr0110(cr());
  cr0111(cr());
  cr1001(cr());
  cr1011(cr());
  cr1100(cr());
  cr1101(cr());
  cr1110(cr());
  cr1111(cr());
  //nl0001(nl);
  //nl0010(nl);
  //nl0011(nl);
  nl0100(nl);
  nl0101(nl);
  nl0110(nl);
  nl0111(nl);
  nl1000(nl);
  nl1001(nl);
  nl1010(nl);
  nl1011(nl);
  nl1100(nl);
  nl1101(nl);
  nl1110(nl);
  nl1111(nl);
  //ncl0001(ncl);
  //ncl0011(ncl);
  ncl0100(ncl);
  ncl0101(ncl);
  ncl0110(ncl);
  ncl0111(ncl);
  //ncl1001(ncl);
  //ncl1011(ncl);
  ncl1100(ncl);
  ncl1101(ncl);
  ncl1110(ncl);
  ncl1111(ncl);
  //nr0001(nr);
  //nr0010(nr);
  //nr0011(nr);
  nr0100(nr);
  nr0101(nr);
  nr0110(nr);
  nr0111(nr);
  nr1000(nr);
  nr1001(nr);
  nr1010(nr);
  nr1011(nr);
  nr1100(nr);
  nr1101(nr);
  nr1110(nr);
  nr1111(nr);
  //ncr0001(ncr);
  //ncr0011(ncr);
  ncr0100(ncr);
  ncr0101(ncr);
  ncr0110(ncr);
  ncr0111(ncr);
  //ncr1001(ncr);
  //ncr1011(ncr);
  ncr1100(ncr);
  ncr1101(ncr);
  ncr1110(ncr);
  ncr1111(ncr);
  //ul0001(ul());
  //ul0010(ul());
  //ul0011(ul());
  ul0100(ul());
  ul0101(ul());
  ul0110(ul());
  ul0111(ul());
  ul1000(ul());
  ul1001(ul());
  ul1010(ul());
  ul1011(ul());
  ul1100(ul());
  ul1101(ul());
  ul1110(ul());
  ul1111(ul());
  //ucl0001(ucl());
  //ucl0011(ucl());
  ucl0100(ucl());
  ucl0101(ucl());
  ucl0110(ucl());
  ucl0111(ucl());
  //ucl1001(ucl());
  //ucl1011(ucl());
  ucl1100(ucl());
  ucl1101(ucl());
  ucl1110(ucl());
  ucl1111(ucl());
  ur0001(ur());
  ur0010(ur());
  ur0011(ur());
  ur0100(ur());
  ur0101(ur());
  ur0110(ur());
  ur0111(ur());
  ur1001(ur());
  ur1010(ur());
  ur1011(ur());
  ur1100(ur());
  ur1101(ur());
  ur1110(ur());
  ur1111(ur());
  ucr0001(ucr());
  ucr0011(ucr());
  ucr0100(ucr());
  ucr0101(ucr());
  ucr0110(ucr());
  ucr0111(ucr());
  ucr1001(ucr());
  ucr1011(ucr());
  ucr1100(ucr());
  ucr1101(ucr());
  ucr1110(ucr());
  ucr1111(ucr());
 
  return 0;
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [g++.dg/] [cpp0x/] [overload.C] - Blame information for rev 774

Line No.	Rev	Author	Line
1	693	jeremybenn	`// { dg-options "--std=c++0x" }`
2			`// { dg-do link }`
3			`// Generated by overload.py`
4
5			`template`
6			`inline _Tp&&`
7			`movel(_Tp& __t)`
8			`{ return static_cast<_Tp&&>(__t); }`
9
10			`struct S{};`
11
12			`S l; // lvalue (l)`
13			`S const cl = l; // const lvalue (cl)`
14			`S r() { return l; } // rvalue (r)`
15			`S const cr() { return l; } // const rvalue (cr)`
16			`S & nl = l; // named lvalue reference (nl)`
17			`S const & ncl = l; // named const lvalue reference (ncl)`
18			`S && nr = movel(l); // named rvalue reference (nr)`
19			`S const && ncr = movel(l); // named const rvalue reference (ncr)`
20			`S & ul() { return l; } // unnamed lvalue reference (ul)`
21			`S const & ucl() { return l; } // unnamed const lvalue reference (ucl)`
22			`S && ur() { return movel(l); } // unnamed rvalue reference (ur)`
23			`S const && ucr() { return movel(l); } // unnamed const rvalue reference (ucr)`
24
25			`void l0001(const S&&) {}`
26
27			`void l0010(S&&) {}`
28
29			`void l0011(S&&) {}`
30			`void l0011(const S&&);`
31
32			`void l0100(const S&) {}`
33
34			`void l0101(const S&) {}`
35			`void l0101(const S&&);`
36
37			`void l0110(const S&) {}`
38			`void l0110(S&&);`
39
40			`void l0111(const S&) {}`
41			`void l0111(S&&);`
42			`void l0111(const S&&);`
43
44			`void l1000(S&) {}`
45
46			`void l1001(S&) {}`
47			`void l1001(const S&&);`
48
49			`void l1010(S&) {}`
50			`void l1010(S&&);`
51
52			`void l1011(S&) {}`
53			`void l1011(S&&);`
54			`void l1011(const S&&);`
55
56			`void l1100(S&) {}`
57			`void l1100(const S&);`
58
59			`void l1101(S&) {}`
60			`void l1101(const S&);`
61			`void l1101(const S&&);`
62
63			`void l1110(S&) {}`
64			`void l1110(const S&);`
65			`void l1110(S&&);`
66
67			`void l1111(S&) {}`
68			`void l1111(const S&);`
69			`void l1111(S&&);`
70			`void l1111(const S&&);`
71
72			`void cl0001(const S&&) {}`
73
74			`void cl0011(S&&);`
75			`void cl0011(const S&&) {}`
76
77			`void cl0100(const S&) {}`
78
79			`void cl0101(const S&) {}`
80			`void cl0101(const S&&);`
81
82			`void cl0110(const S&) {}`
83			`void cl0110(S&&);`
84
85			`void cl0111(const S&) {}`
86			`void cl0111(S&&);`
87			`void cl0111(const S&&);`
88
89			`void cl1001(S&);`
90			`void cl1001(const S&&) {}`
91
92			`void cl1011(S&);`
93			`void cl1011(S&&);`
94			`void cl1011(const S&&) {}`
95
96			`void cl1100(S&);`
97			`void cl1100(const S&) {}`
98
99			`void cl1101(S&);`
100			`void cl1101(const S&) {}`
101			`void cl1101(const S&&);`
102
103			`void cl1110(S&);`
104			`void cl1110(const S&) {}`
105			`void cl1110(S&&);`
106
107			`void cl1111(S&);`
108			`void cl1111(const S&) {}`
109			`void cl1111(S&&);`
110			`void cl1111(const S&&);`
111
112			`void r0001(const S&&) {}`
113
114			`void r0010(S&&) {}`
115
116			`void r0011(S&&) {}`
117			`void r0011(const S&&);`
118
119			`void r0100(const S&) {}`
120
121			`void r0101(const S&);`
122			`void r0101(const S&&) {}`
123
124			`void r0110(const S&);`
125			`void r0110(S&&) {}`
126
127			`void r0111(const S&);`
128			`void r0111(S&&) {}`
129			`void r0111(const S&&);`
130
131			`void r1001(S&);`
132			`void r1001(const S&&) {}`
133
134			`void r1010(S&);`
135			`void r1010(S&&) {}`
136
137			`void r1011(S&);`
138			`void r1011(S&&) {}`
139			`void r1011(const S&&);`
140
141			`void r1100(S&);`
142			`void r1100(const S&) {}`
143
144			`void r1101(S&);`
145			`void r1101(const S&);`
146			`void r1101(const S&&) {}`
147
148			`void r1110(S&);`
149			`void r1110(const S&);`
150			`void r1110(S&&) {}`
151
152			`void r1111(S&);`
153			`void r1111(const S&);`
154			`void r1111(S&&) {}`
155			`void r1111(const S&&);`
156
157			`void cr0001(const S&&) {}`
158
159			`void cr0011(S&&);`
160			`void cr0011(const S&&) {}`
161
162			`void cr0100(const S&) {}`
163
164			`void cr0101(const S&);`
165			`void cr0101(const S&&) {}`
166
167			`void cr0110(const S&) {}`
168			`void cr0110(S&&);`
169
170			`void cr0111(const S&);`
171			`void cr0111(S&&);`
172			`void cr0111(const S&&) {}`
173
174			`void cr1001(S&);`
175			`void cr1001(const S&&) {}`
176
177			`void cr1011(S&);`
178			`void cr1011(S&&);`
179			`void cr1011(const S&&) {}`
180
181			`void cr1100(S&);`
182			`void cr1100(const S&) {}`
183
184			`void cr1101(S&);`
185			`void cr1101(const S&);`
186			`void cr1101(const S&&) {}`
187
188			`void cr1110(S&);`
189			`void cr1110(const S&) {}`
190			`void cr1110(S&&);`
191
192			`void cr1111(S&);`
193			`void cr1111(const S&);`
194			`void cr1111(S&&);`
195			`void cr1111(const S&&) {}`
196
197			`void nl0001(const S&&) {}`
198
199			`void nl0010(S&&) {}`
200
201			`void nl0011(S&&) {}`
202			`void nl0011(const S&&);`
203
204			`void nl0100(const S&) {}`
205
206			`void nl0101(const S&) {}`
207			`void nl0101(const S&&);`
208
209			`void nl0110(const S&) {}`
210			`void nl0110(S&&);`
211
212			`void nl0111(const S&) {}`
213			`void nl0111(S&&);`
214			`void nl0111(const S&&);`
215
216			`void nl1000(S&) {}`
217
218			`void nl1001(S&) {}`
219			`void nl1001(const S&&);`
220
221			`void nl1010(S&) {}`
222			`void nl1010(S&&);`
223
224			`void nl1011(S&) {}`
225			`void nl1011(S&&);`
226			`void nl1011(const S&&);`
227
228			`void nl1100(S&) {}`
229			`void nl1100(const S&);`
230
231			`void nl1101(S&) {}`
232			`void nl1101(const S&);`
233			`void nl1101(const S&&);`
234
235			`void nl1110(S&) {}`
236			`void nl1110(const S&);`
237			`void nl1110(S&&);`
238
239			`void nl1111(S&) {}`
240			`void nl1111(const S&);`
241			`void nl1111(S&&);`
242			`void nl1111(const S&&);`
243
244			`void ncl0001(const S&&) {}`
245
246			`void ncl0011(S&&);`
247			`void ncl0011(const S&&) {}`
248
249			`void ncl0100(const S&) {}`
250
251			`void ncl0101(const S&) {}`
252			`void ncl0101(const S&&);`
253
254			`void ncl0110(const S&) {}`
255			`void ncl0110(S&&);`
256
257			`void ncl0111(const S&) {}`
258			`void ncl0111(S&&);`
259			`void ncl0111(const S&&);`
260
261			`void ncl1001(S&);`
262			`void ncl1001(const S&&) {}`
263
264			`void ncl1011(S&);`
265			`void ncl1011(S&&);`
266			`void ncl1011(const S&&) {}`
267
268			`void ncl1100(S&);`
269			`void ncl1100(const S&) {}`
270
271			`void ncl1101(S&);`
272			`void ncl1101(const S&) {}`
273			`void ncl1101(const S&&);`
274
275			`void ncl1110(S&);`
276			`void ncl1110(const S&) {}`
277			`void ncl1110(S&&);`
278
279			`void ncl1111(S&);`
280			`void ncl1111(const S&) {}`
281			`void ncl1111(S&&);`
282			`void ncl1111(const S&&);`
283
284			`void nr0001(const S&&) {}`
285
286			`void nr0010(S&&) {}`
287
288			`void nr0011(S&&) {}`
289			`void nr0011(const S&&);`
290
291			`void nr0100(const S&) {}`
292
293			`void nr0101(const S&) {}`
294			`void nr0101(const S&&);`
295
296			`void nr0110(const S&) {}`
297			`void nr0110(S&&);`
298
299			`void nr0111(const S&) {}`
300			`void nr0111(S&&);`
301			`void nr0111(const S&&);`
302
303			`void nr1000(S&) {}`
304
305			`void nr1001(S&) {}`
306			`void nr1001(const S&&);`
307
308			`void nr1010(S&) {}`
309			`void nr1010(S&&);`
310
311			`void nr1011(S&) {}`
312			`void nr1011(S&&);`
313			`void nr1011(const S&&);`
314
315			`void nr1100(S&) {}`
316			`void nr1100(const S&);`
317
318			`void nr1101(S&) {}`
319			`void nr1101(const S&);`
320			`void nr1101(const S&&);`
321
322			`void nr1110(S&) {}`
323			`void nr1110(const S&);`
324			`void nr1110(S&&);`
325
326			`void nr1111(S&) {}`
327			`void nr1111(const S&);`
328			`void nr1111(S&&);`
329			`void nr1111(const S&&);`
330
331			`void ncr0001(const S&&) {}`
332
333			`void ncr0011(S&&);`
334			`void ncr0011(const S&&) {}`
335
336			`void ncr0100(const S&) {}`
337
338			`void ncr0101(const S&) {}`
339			`void ncr0101(const S&&);`
340
341			`void ncr0110(const S&) {}`
342			`void ncr0110(S&&);`
343
344			`void ncr0111(const S&) {}`
345			`void ncr0111(S&&);`
346			`void ncr0111(const S&&);`
347
348			`void ncr1001(S&);`
349			`void ncr1001(const S&&) {}`
350
351			`void ncr1011(S&);`
352			`void ncr1011(S&&);`
353			`void ncr1011(const S&&) {}`
354
355			`void ncr1100(S&);`
356			`void ncr1100(const S&) {}`
357
358			`void ncr1101(S&);`
359			`void ncr1101(const S&) {}`
360			`void ncr1101(const S&&);`
361
362			`void ncr1110(S&);`
363			`void ncr1110(const S&) {}`
364			`void ncr1110(S&&);`
365
366			`void ncr1111(S&);`
367			`void ncr1111(const S&) {}`
368			`void ncr1111(S&&);`
369			`void ncr1111(const S&&);`
370
371			`void ul0001(const S&&) {}`
372
373			`void ul0010(S&&) {}`
374
375			`void ul0011(S&&) {}`
376			`void ul0011(const S&&);`
377
378			`void ul0100(const S&) {}`
379
380			`void ul0101(const S&) {}`
381			`void ul0101(const S&&);`
382
383			`void ul0110(const S&) {}`
384			`void ul0110(S&&);`
385
386			`void ul0111(const S&) {}`
387			`void ul0111(S&&);`
388			`void ul0111(const S&&);`
389
390			`void ul1000(S&) {}`
391
392			`void ul1001(S&) {}`
393			`void ul1001(const S&&);`
394
395			`void ul1010(S&) {}`
396			`void ul1010(S&&);`
397
398			`void ul1011(S&) {}`
399			`void ul1011(S&&);`
400			`void ul1011(const S&&);`
401
402			`void ul1100(S&) {}`
403			`void ul1100(const S&);`
404
405			`void ul1101(S&) {}`
406			`void ul1101(const S&);`
407			`void ul1101(const S&&);`
408
409			`void ul1110(S&) {}`
410			`void ul1110(const S&);`
411			`void ul1110(S&&);`
412
413			`void ul1111(S&) {}`
414			`void ul1111(const S&);`
415			`void ul1111(S&&);`
416			`void ul1111(const S&&);`
417
418			`void ucl0001(const S&&) {}`
419
420			`void ucl0011(S&&);`
421			`void ucl0011(const S&&) {}`
422
423			`void ucl0100(const S&) {}`
424
425			`void ucl0101(const S&) {}`
426			`void ucl0101(const S&&);`
427
428			`void ucl0110(const S&) {}`
429			`void ucl0110(S&&);`
430
431			`void ucl0111(const S&) {}`
432			`void ucl0111(S&&);`
433			`void ucl0111(const S&&);`
434
435			`void ucl1001(S&);`
436			`void ucl1001(const S&&) {}`
437
438			`void ucl1011(S&);`
439			`void ucl1011(S&&);`
440			`void ucl1011(const S&&) {}`
441
442			`void ucl1100(S&);`
443			`void ucl1100(const S&) {}`
444
445			`void ucl1101(S&);`
446			`void ucl1101(const S&) {}`
447			`void ucl1101(const S&&);`
448
449			`void ucl1110(S&);`
450			`void ucl1110(const S&) {}`
451			`void ucl1110(S&&);`
452
453			`void ucl1111(S&);`
454			`void ucl1111(const S&) {}`
455			`void ucl1111(S&&);`
456			`void ucl1111(const S&&);`
457
458			`void ur0001(const S&&) {}`
459
460			`void ur0010(S&&) {}`
461
462			`void ur0011(S&&) {}`
463			`void ur0011(const S&&);`
464
465			`void ur0100(const S&) {}`
466
467			`void ur0101(const S&);`
468			`void ur0101(const S&&) {}`
469
470			`void ur0110(const S&);`
471			`void ur0110(S&&) {}`
472
473			`void ur0111(const S&);`
474			`void ur0111(S&&) {}`
475			`void ur0111(const S&&);`
476
477			`void ur1001(S&);`
478			`void ur1001(const S&&) {}`
479
480			`void ur1010(S&);`
481			`void ur1010(S&&) {}`
482
483			`void ur1011(S&);`
484			`void ur1011(S&&) {}`
485			`void ur1011(const S&&);`
486
487			`void ur1100(S&);`
488			`void ur1100(const S&) {}`
489
490			`void ur1101(S&);`
491			`void ur1101(const S&);`
492			`void ur1101(const S&&) {}`
493
494			`void ur1110(S&);`
495			`void ur1110(const S&);`
496			`void ur1110(S&&) {}`
497
498			`void ur1111(S&);`
499			`void ur1111(const S&);`
500			`void ur1111(S&&) {}`
501			`void ur1111(const S&&);`
502
503			`void ucr0001(const S&&) {}`
504
505			`void ucr0011(S&&);`
506			`void ucr0011(const S&&) {}`
507
508			`void ucr0100(const S&) {}`
509
510			`void ucr0101(const S&);`
511			`void ucr0101(const S&&) {}`
512
513			`void ucr0110(const S&) {}`
514			`void ucr0110(S&&);`
515
516			`void ucr0111(const S&);`
517			`void ucr0111(S&&);`
518			`void ucr0111(const S&&) {}`
519
520			`void ucr1001(S&);`
521			`void ucr1001(const S&&) {}`
522
523			`void ucr1011(S&);`
524			`void ucr1011(S&&);`
525			`void ucr1011(const S&&) {}`
526
527			`void ucr1100(S&);`
528			`void ucr1100(const S&) {}`
529
530			`void ucr1101(S&);`
531			`void ucr1101(const S&);`
532			`void ucr1101(const S&&) {}`
533
534			`void ucr1110(S&);`
535			`void ucr1110(const S&) {}`
536			`void ucr1110(S&&);`
537
538			`void ucr1111(S&);`
539			`void ucr1111(const S&);`
540			`void ucr1111(S&&);`
541			`void ucr1111(const S&&) {}`
542
543
544			`int main()`
545			`{`
546			`//l0001(l);`
547			`//l0010(l);`
548			`//l0011(l);`
549			`l0100(l);`
550			`l0101(l);`
551			`l0110(l);`
552			`l0111(l);`
553			`l1000(l);`
554			`l1001(l);`
555			`l1010(l);`
556			`l1011(l);`
557			`l1100(l);`
558			`l1101(l);`
559			`l1110(l);`
560			`l1111(l);`
561			`//cl0001(cl);`
562			`//cl0011(cl);`
563			`cl0100(cl);`
564			`cl0101(cl);`
565			`cl0110(cl);`
566			`cl0111(cl);`
567			`//cl1001(cl);`
568			`//cl1011(cl);`
569			`cl1100(cl);`
570			`cl1101(cl);`
571			`cl1110(cl);`
572			`cl1111(cl);`
573			`r0001(r());`
574			`r0010(r());`
575			`r0011(r());`
576			`r0100(r());`
577			`r0101(r());`
578			`r0110(r());`
579			`r0111(r());`
580			`r1001(r());`
581			`r1010(r());`
582			`r1011(r());`
583			`r1100(r());`
584			`r1101(r());`
585			`r1110(r());`
586			`r1111(r());`
587			`cr0001(cr());`
588			`cr0011(cr());`
589			`cr0100(cr());`
590			`cr0101(cr());`
591			`cr0110(cr());`
592			`cr0111(cr());`
593			`cr1001(cr());`
594			`cr1011(cr());`
595			`cr1100(cr());`
596			`cr1101(cr());`
597			`cr1110(cr());`
598			`cr1111(cr());`
599			`//nl0001(nl);`
600			`//nl0010(nl);`
601			`//nl0011(nl);`
602			`nl0100(nl);`
603			`nl0101(nl);`
604			`nl0110(nl);`
605			`nl0111(nl);`
606			`nl1000(nl);`
607			`nl1001(nl);`
608			`nl1010(nl);`
609			`nl1011(nl);`
610			`nl1100(nl);`
611			`nl1101(nl);`
612			`nl1110(nl);`
613			`nl1111(nl);`
614			`//ncl0001(ncl);`
615			`//ncl0011(ncl);`
616			`ncl0100(ncl);`
617			`ncl0101(ncl);`
618			`ncl0110(ncl);`
619			`ncl0111(ncl);`
620			`//ncl1001(ncl);`
621			`//ncl1011(ncl);`
622			`ncl1100(ncl);`
623			`ncl1101(ncl);`
624			`ncl1110(ncl);`
625			`ncl1111(ncl);`
626			`//nr0001(nr);`
627			`//nr0010(nr);`
628			`//nr0011(nr);`
629			`nr0100(nr);`
630			`nr0101(nr);`
631			`nr0110(nr);`
632			`nr0111(nr);`
633			`nr1000(nr);`
634			`nr1001(nr);`
635			`nr1010(nr);`
636			`nr1011(nr);`
637			`nr1100(nr);`
638			`nr1101(nr);`
639			`nr1110(nr);`
640			`nr1111(nr);`
641			`//ncr0001(ncr);`
642			`//ncr0011(ncr);`
643			`ncr0100(ncr);`
644			`ncr0101(ncr);`
645			`ncr0110(ncr);`
646			`ncr0111(ncr);`
647			`//ncr1001(ncr);`
648			`//ncr1011(ncr);`
649			`ncr1100(ncr);`
650			`ncr1101(ncr);`
651			`ncr1110(ncr);`
652			`ncr1111(ncr);`
653			`//ul0001(ul());`
654			`//ul0010(ul());`
655			`//ul0011(ul());`
656			`ul0100(ul());`
657			`ul0101(ul());`
658			`ul0110(ul());`
659			`ul0111(ul());`
660			`ul1000(ul());`
661			`ul1001(ul());`
662			`ul1010(ul());`
663			`ul1011(ul());`
664			`ul1100(ul());`
665			`ul1101(ul());`
666			`ul1110(ul());`
667			`ul1111(ul());`
668			`//ucl0001(ucl());`
669			`//ucl0011(ucl());`
670			`ucl0100(ucl());`
671			`ucl0101(ucl());`
672			`ucl0110(ucl());`
673			`ucl0111(ucl());`
674			`//ucl1001(ucl());`
675			`//ucl1011(ucl());`
676			`ucl1100(ucl());`
677			`ucl1101(ucl());`
678			`ucl1110(ucl());`
679			`ucl1111(ucl());`
680			`ur0001(ur());`
681			`ur0010(ur());`
682			`ur0011(ur());`
683			`ur0100(ur());`
684			`ur0101(ur());`
685			`ur0110(ur());`
686			`ur0111(ur());`
687			`ur1001(ur());`
688			`ur1010(ur());`
689			`ur1011(ur());`
690			`ur1100(ur());`
691			`ur1101(ur());`
692			`ur1110(ur());`
693			`ur1111(ur());`
694			`ucr0001(ucr());`
695			`ucr0011(ucr());`
696			`ucr0100(ucr());`
697			`ucr0101(ucr());`
698			`ucr0110(ucr());`
699			`ucr0111(ucr());`
700			`ucr1001(ucr());`
701			`ucr1011(ucr());`
702			`ucr1100(ucr());`
703			`ucr1101(ucr());`
704			`ucr1110(ucr());`
705			`ucr1111(ucr());`
706
707			`return 0;`
708			`}`