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

Subversion Repositories openrisc

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

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


// I, Howard Hinnant, hereby place this code in the public domain.
 
// Test overload resolution among reference types
 
// { dg-do compile }
// { dg-options "-std=c++0x" }
 
template  struct sa;
template <> struct sa {};
 
struct one   {long x[1];};
struct two   {long x[2];};
struct three {long x[3];};
struct four  {long x[4];};
struct five  {long x[5];};
struct six   {long x[6];};
struct seven {long x[7];};
struct eight {long x[8];};
 
struct A
{
    A();
    A(const volatile A&&);
};
 
               A    source();
const          A  c_source();
      volatile A  v_source();
const volatile A cv_source();
 
// 3 at a time
 
one   sink_3_123(               A&);
two   sink_3_123(const          A&);
three sink_3_123(volatile       A&);
 
int test3_123()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t3;
    sa t5;
    sa t6;
    return 0;
}
 
one   sink_3_124(               A&);
two   sink_3_124(const          A&);
four  sink_3_124(const volatile A&);
 
int test3_124()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    return 0;
}
 
one   sink_3_125(               A&);
two   sink_3_125(const          A&);
five  sink_3_125(               A&&);
 
int test3_125()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t5;
    sa t6;
    return 0;
}
 
one   sink_3_126(               A&);
two   sink_3_126(const          A&);
six   sink_3_126(const          A&&);
 
int test3_126()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t5;
    sa t6;
    return 0;
}
 
one   sink_3_127(               A&);
two   sink_3_127(const          A&);
seven sink_3_127(volatile       A&&);
 
int test3_127()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t5;
    sa t6;
    sa t7;
    return 0;
}
 
one   sink_3_128(               A&);
two   sink_3_128(const          A&);
eight sink_3_128(const volatile A&&);
 
int test3_128()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_3_134(               A&);
three sink_3_134(volatile       A&);
four  sink_3_134(const volatile A&);
 
int test3_134()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    return 0;
}
 
one   sink_3_135(               A&);
three sink_3_135(volatile       A&);
five  sink_3_135(               A&&);
 
int test3_135()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t3;
    sa t5;
    return 0;
}
 
one   sink_3_136(               A&);
three sink_3_136(volatile       A&);
six   sink_3_136(const          A&&);
 
int test3_136()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t3;
    sa t5;
    sa t6;
    return 0;
}
 
one   sink_3_137(               A&);
three sink_3_137(volatile       A&);
seven sink_3_137(volatile       A&&);
 
int test3_137()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t3;
    sa t5;
    sa t7;
    return 0;
}
 
one   sink_3_138(               A&);
three sink_3_138(volatile       A&);
eight sink_3_138(const volatile A&&);
 
int test3_138()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t3;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_3_145(               A&);
four  sink_3_145(const volatile A&);
five  sink_3_145(               A&&);
 
int test3_145()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    return 0;
}
 
one   sink_3_146(               A&);
four  sink_3_146(const volatile A&);
six   sink_3_146(const          A&&);
 
int test3_146()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    return 0;
}
 
one   sink_3_147(               A&);
four  sink_3_147(const volatile A&);
seven sink_3_147(volatile       A&&);
 
int test3_147()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t7;
    return 0;
}
 
one   sink_3_148(               A&);
four  sink_3_148(const volatile A&);
eight sink_3_148(const volatile A&&);
 
int test3_148()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_3_156(               A&);
five  sink_3_156(               A&&);
six   sink_3_156(const          A&&);
 
int test3_156()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t5;
    sa t6;
    return 0;
}
 
one   sink_3_157(               A&);
five  sink_3_157(               A&&);
seven sink_3_157(volatile       A&&);
 
int test3_157()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t5;
    sa t7;
    return 0;
}
 
one   sink_3_158(               A&);
five  sink_3_158(               A&&);
eight sink_3_158(const volatile A&&);
 
int test3_158()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_3_167(               A&);
six   sink_3_167(const          A&&);
seven sink_3_167(volatile       A&&);
 
int test3_167()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t6;
    sa t7;
    return 0;
}
 
one   sink_3_168(               A&);
six   sink_3_168(const          A&&);
eight sink_3_168(const volatile A&&);
 
int test3_168()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_3_178(               A&);
seven sink_3_178(volatile       A&&);
eight sink_3_178(const volatile A&&);
 
int test3_178()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
two   sink_3_234(const          A&);
three sink_3_234(volatile       A&);
four  sink_3_234(const volatile A&);
 
int test3_234()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    return 0;
}
 
two   sink_3_235(const          A&);
three sink_3_235(volatile       A&);
five  sink_3_235(               A&&);
 
int test3_235()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t2;
    sa t3;
    sa t5;
    sa t6;
    return 0;
}
 
two   sink_3_236(const          A&);
three sink_3_236(volatile       A&);
six   sink_3_236(const          A&&);
 
int test3_236()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t2;
    sa t3;
    sa t5;
    sa t6;
    return 0;
}
 
two   sink_3_237(const          A&);
three sink_3_237(volatile       A&);
seven sink_3_237(volatile       A&&);
 
int test3_237()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t2;
    sa t3;
    sa t5;
    sa t6;
    sa t7;
    return 0;
}
 
two   sink_3_238(const          A&);
three sink_3_238(volatile       A&);
eight sink_3_238(const volatile A&&);
 
int test3_238()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t2;
    sa t3;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
two   sink_3_245(const          A&);
four  sink_3_245(const volatile A&);
five  sink_3_245(               A&&);
 
int test3_245()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    return 0;
}
 
two   sink_3_246(const          A&);
four  sink_3_246(const volatile A&);
six   sink_3_246(const          A&&);
 
int test3_246()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    return 0;
}
 
two   sink_3_247(const          A&);
four  sink_3_247(const volatile A&);
seven sink_3_247(volatile       A&&);
 
int test3_247()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    return 0;
}
 
two   sink_3_248(const          A&);
four  sink_3_248(const volatile A&);
eight sink_3_248(const volatile A&&);
 
int test3_248()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
two   sink_3_256(const          A&);
five  sink_3_256(               A&&);
six   sink_3_256(const          A&&);
 
int test3_256()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t5;
    sa t6;
    return 0;
}
 
two   sink_3_257(const          A&);
five  sink_3_257(               A&&);
seven sink_3_257(volatile       A&&);
 
int test3_257()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t5;
    sa t6;
    sa t7;
    return 0;
}
 
two   sink_3_258(const          A&);
five  sink_3_258(               A&&);
eight sink_3_258(const volatile A&&);
 
int test3_258()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
two   sink_3_267(const          A&);
six   sink_3_267(const          A&&);
seven sink_3_267(volatile       A&&);
 
int test3_267()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t6;
    sa t7;
    return 0;
}
 
two   sink_3_268(const          A&);
six   sink_3_268(const          A&&);
eight sink_3_268(const volatile A&&);
 
int test3_268()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
two   sink_3_278(const          A&);
seven sink_3_278(volatile       A&&);
eight sink_3_278(const volatile A&&);
 
int test3_278()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
three sink_3_345(volatile       A&);
four  sink_3_345(const volatile A&);
five  sink_3_345(               A&&);
 
int test3_345()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    return 0;
}
 
three sink_3_346(volatile       A&);
four  sink_3_346(const volatile A&);
six   sink_3_346(const          A&&);
 
int test3_346()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    return 0;
}
 
three sink_3_347(volatile       A&);
four  sink_3_347(const volatile A&);
seven sink_3_347(volatile       A&&);
 
int test3_347()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t7;
    return 0;
}
 
three sink_3_348(volatile       A&);
four  sink_3_348(const volatile A&);
eight sink_3_348(const volatile A&&);
 
int test3_348()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
three sink_3_356(volatile       A&);
five  sink_3_356(               A&&);
six   sink_3_356(const          A&&);
 
int test3_356()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t3;
    sa t5;
    sa t6;
    return 0;
}
 
three sink_3_357(volatile       A&);
five  sink_3_357(               A&&);
seven sink_3_357(volatile       A&&);
 
int test3_357()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t3;
    sa t5;
    sa t7;
    return 0;
}
 
three sink_3_358(volatile       A&);
five  sink_3_358(               A&&);
eight sink_3_358(const volatile A&&);
 
int test3_358()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t3;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
three sink_3_367(volatile       A&);
six   sink_3_367(const          A&&);
seven sink_3_367(volatile       A&&);
 
int test3_367()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t3;
    sa t6;
    sa t7;
    return 0;
}
 
three sink_3_368(volatile       A&);
six   sink_3_368(const          A&&);
eight sink_3_368(const volatile A&&);
 
int test3_368()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t3;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
three sink_3_378(volatile       A&);
seven sink_3_378(volatile       A&&);
eight sink_3_378(const volatile A&&);
 
int test3_378()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t3;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
four  sink_3_456(const volatile A&);
five  sink_3_456(               A&&);
six   sink_3_456(const          A&&);
 
int test3_456()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    return 0;
}
 
four  sink_3_457(const volatile A&);
five  sink_3_457(               A&&);
seven sink_3_457(volatile       A&&);
 
int test3_457()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t7;
    return 0;
}
 
four  sink_3_458(const volatile A&);
five  sink_3_458(               A&&);
eight sink_3_458(const volatile A&&);
 
int test3_458()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
four  sink_3_467(const volatile A&);
six   sink_3_467(const          A&&);
seven sink_3_467(volatile       A&&);
 
int test3_467()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t6;
    sa t7;
    return 0;
}
 
four  sink_3_468(const volatile A&);
six   sink_3_468(const          A&&);
eight sink_3_468(const volatile A&&);
 
int test3_468()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
four  sink_3_478(const volatile A&);
seven sink_3_478(volatile       A&&);
eight sink_3_478(const volatile A&&);
 
int test3_478()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
five  sink_3_567(               A&&);
six   sink_3_567(const          A&&);
seven sink_3_567(volatile       A&&);
 
int test3_567()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t5;
    sa t6;
    sa t7;
    return 0;
}
 
five  sink_3_568(               A&&);
six   sink_3_568(const          A&&);
eight sink_3_568(const volatile A&&);
 
int test3_568()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
five  sink_3_578(               A&&);
seven sink_3_578(volatile       A&&);
eight sink_3_578(const volatile A&&);
 
int test3_578()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
six   sink_3_678(const          A&&);
seven sink_3_678(volatile       A&&);
eight sink_3_678(const volatile A&&);
 
int test3_678()
{
                   A a;
    const          A ca;
          volatile A va;
    const volatile A cva;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
int main()
{
    return test3_123() + test3_124() + test3_125() + test3_126() +
           test3_127() + test3_128() + test3_134() + test3_135() +
           test3_136() + test3_137() + test3_138() + test3_145() +
           test3_146() + test3_147() + test3_148() + test3_156() +
           test3_157() + test3_158() + test3_167() + test3_168() +
           test3_178() + test3_234() + test3_235() + test3_236() +
           test3_237() + test3_238() + test3_245() + test3_246() +
           test3_247() + test3_248() + test3_256() + test3_257() +
           test3_258() + test3_267() + test3_268() + test3_278() +
           test3_345() + test3_346() + test3_347() + test3_348() +
           test3_356() + test3_357() + test3_358() + test3_367() +
           test3_368() + test3_378() + test3_456() + test3_457() +
           test3_458() + test3_467() + test3_468() + test3_478() +
           test3_567() + test3_568() + test3_578() + test3_678();
}

Browse

Tools

Subversion Repositories openrisc

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

Line No.	Rev	Author	Line
1	693	jeremybenn	`// I, Howard Hinnant, hereby place this code in the public domain.`
2
3			`// Test overload resolution among reference types`
4
5			`// { dg-do compile }`
6			`// { dg-options "-std=c++0x" }`
7
8			`template struct sa;`
9			`template <> struct sa {};`
10
11			`struct one {long x[1];};`
12			`struct two {long x[2];};`
13			`struct three {long x[3];};`
14			`struct four {long x[4];};`
15			`struct five {long x[5];};`
16			`struct six {long x[6];};`
17			`struct seven {long x[7];};`
18			`struct eight {long x[8];};`
19
20			`struct A`
21			`{`
22			`A();`
23			`A(const volatile A&&);`
24			`};`
25
26			`A source();`
27			`const A c_source();`
28			`volatile A v_source();`
29			`const volatile A cv_source();`
30
31			`// 3 at a time`
32
33			`one sink_3_123( A&);`
34			`two sink_3_123(const A&);`
35			`three sink_3_123(volatile A&);`
36
37			`int test3_123()`
38			`{`
39			`A a;`
40			`const A ca;`
41			`volatile A va;`
42			`const volatile A cva;`
43			`sa t1;`
44			`sa t2;`
45			`sa t3;`
46			`sa t5;`
47			`sa t6;`
48			`return 0;`
49			`}`
50
51			`one sink_3_124( A&);`
52			`two sink_3_124(const A&);`
53			`four sink_3_124(const volatile A&);`
54
55			`int test3_124()`
56			`{`
57			`A a;`
58			`const A ca;`
59			`volatile A va;`
60			`const volatile A cva;`
61			`sa t1;`
62			`sa t2;`
63			`sa t3;`
64			`sa t4;`
65			`sa t5;`
66			`sa t6;`
67			`return 0;`
68			`}`
69
70			`one sink_3_125( A&);`
71			`two sink_3_125(const A&);`
72			`five sink_3_125( A&&);`
73
74			`int test3_125()`
75			`{`
76			`A a;`
77			`const A ca;`
78			`volatile A va;`
79			`const volatile A cva;`
80			`sa t1;`
81			`sa t2;`
82			`sa t5;`
83			`sa t6;`
84			`return 0;`
85			`}`
86
87			`one sink_3_126( A&);`
88			`two sink_3_126(const A&);`
89			`six sink_3_126(const A&&);`
90
91			`int test3_126()`
92			`{`
93			`A a;`
94			`const A ca;`
95			`volatile A va;`
96			`const volatile A cva;`
97			`sa t1;`
98			`sa t2;`
99			`sa t5;`
100			`sa t6;`
101			`return 0;`
102			`}`
103
104			`one sink_3_127( A&);`
105			`two sink_3_127(const A&);`
106			`seven sink_3_127(volatile A&&);`
107
108			`int test3_127()`
109			`{`
110			`A a;`
111			`const A ca;`
112			`volatile A va;`
113			`const volatile A cva;`
114			`sa t1;`
115			`sa t2;`
116			`sa t5;`
117			`sa t6;`
118			`sa t7;`
119			`return 0;`
120			`}`
121
122			`one sink_3_128( A&);`
123			`two sink_3_128(const A&);`
124			`eight sink_3_128(const volatile A&&);`
125
126			`int test3_128()`
127			`{`
128			`A a;`
129			`const A ca;`
130			`volatile A va;`
131			`const volatile A cva;`
132			`sa t1;`
133			`sa t2;`
134			`sa t5;`
135			`sa t6;`
136			`sa t7;`
137			`sa t8;`
138			`return 0;`
139			`}`
140
141			`one sink_3_134( A&);`
142			`three sink_3_134(volatile A&);`
143			`four sink_3_134(const volatile A&);`
144
145			`int test3_134()`
146			`{`
147			`A a;`
148			`const A ca;`
149			`volatile A va;`
150			`const volatile A cva;`
151			`sa t1;`
152			`sa t2;`
153			`sa t3;`
154			`sa t4;`
155			`return 0;`
156			`}`
157
158			`one sink_3_135( A&);`
159			`three sink_3_135(volatile A&);`
160			`five sink_3_135( A&&);`
161
162			`int test3_135()`
163			`{`
164			`A a;`
165			`const A ca;`
166			`volatile A va;`
167			`const volatile A cva;`
168			`sa t1;`
169			`sa t3;`
170			`sa t5;`
171			`return 0;`
172			`}`
173
174			`one sink_3_136( A&);`
175			`three sink_3_136(volatile A&);`
176			`six sink_3_136(const A&&);`
177
178			`int test3_136()`
179			`{`
180			`A a;`
181			`const A ca;`
182			`volatile A va;`
183			`const volatile A cva;`
184			`sa t1;`
185			`sa t3;`
186			`sa t5;`
187			`sa t6;`
188			`return 0;`
189			`}`
190
191			`one sink_3_137( A&);`
192			`three sink_3_137(volatile A&);`
193			`seven sink_3_137(volatile A&&);`
194
195			`int test3_137()`
196			`{`
197			`A a;`
198			`const A ca;`
199			`volatile A va;`
200			`const volatile A cva;`
201			`sa t1;`
202			`sa t3;`
203			`sa t5;`
204			`sa t7;`
205			`return 0;`
206			`}`
207
208			`one sink_3_138( A&);`
209			`three sink_3_138(volatile A&);`
210			`eight sink_3_138(const volatile A&&);`
211
212			`int test3_138()`
213			`{`
214			`A a;`
215			`const A ca;`
216			`volatile A va;`
217			`const volatile A cva;`
218			`sa t1;`
219			`sa t3;`
220			`sa t5;`
221			`sa t6;`
222			`sa t7;`
223			`sa t8;`
224			`return 0;`
225			`}`
226
227			`one sink_3_145( A&);`
228			`four sink_3_145(const volatile A&);`
229			`five sink_3_145( A&&);`
230
231			`int test3_145()`
232			`{`
233			`A a;`
234			`const A ca;`
235			`volatile A va;`
236			`const volatile A cva;`
237			`sa t1;`
238			`sa t2;`
239			`sa t3;`
240			`sa t4;`
241			`sa t5;`
242			`return 0;`
243			`}`
244
245			`one sink_3_146( A&);`
246			`four sink_3_146(const volatile A&);`
247			`six sink_3_146(const A&&);`
248
249			`int test3_146()`
250			`{`
251			`A a;`
252			`const A ca;`
253			`volatile A va;`
254			`const volatile A cva;`
255			`sa t1;`
256			`sa t2;`
257			`sa t3;`
258			`sa t4;`
259			`sa t5;`
260			`sa t6;`
261			`return 0;`
262			`}`
263
264			`one sink_3_147( A&);`
265			`four sink_3_147(const volatile A&);`
266			`seven sink_3_147(volatile A&&);`
267
268			`int test3_147()`
269			`{`
270			`A a;`
271			`const A ca;`
272			`volatile A va;`
273			`const volatile A cva;`
274			`sa t1;`
275			`sa t2;`
276			`sa t3;`
277			`sa t4;`
278			`sa t5;`
279			`sa t7;`
280			`return 0;`
281			`}`
282
283			`one sink_3_148( A&);`
284			`four sink_3_148(const volatile A&);`
285			`eight sink_3_148(const volatile A&&);`
286
287			`int test3_148()`
288			`{`
289			`A a;`
290			`const A ca;`
291			`volatile A va;`
292			`const volatile A cva;`
293			`sa t1;`
294			`sa t2;`
295			`sa t3;`
296			`sa t4;`
297			`sa t5;`
298			`sa t6;`
299			`sa t7;`
300			`sa t8;`
301			`return 0;`
302			`}`
303
304			`one sink_3_156( A&);`
305			`five sink_3_156( A&&);`
306			`six sink_3_156(const A&&);`
307
308			`int test3_156()`
309			`{`
310			`A a;`
311			`const A ca;`
312			`volatile A va;`
313			`const volatile A cva;`
314			`sa t1;`
315			`sa t5;`
316			`sa t6;`
317			`return 0;`
318			`}`
319
320			`one sink_3_157( A&);`
321			`five sink_3_157( A&&);`
322			`seven sink_3_157(volatile A&&);`
323
324			`int test3_157()`
325			`{`
326			`A a;`
327			`const A ca;`
328			`volatile A va;`
329			`const volatile A cva;`
330			`sa t1;`
331			`sa t5;`
332			`sa t7;`
333			`return 0;`
334			`}`
335
336			`one sink_3_158( A&);`
337			`five sink_3_158( A&&);`
338			`eight sink_3_158(const volatile A&&);`
339
340			`int test3_158()`
341			`{`
342			`A a;`
343			`const A ca;`
344			`volatile A va;`
345			`const volatile A cva;`
346			`sa t1;`
347			`sa t5;`
348			`sa t6;`
349			`sa t7;`
350			`sa t8;`
351			`return 0;`
352			`}`
353
354			`one sink_3_167( A&);`
355			`six sink_3_167(const A&&);`
356			`seven sink_3_167(volatile A&&);`
357
358			`int test3_167()`
359			`{`
360			`A a;`
361			`const A ca;`
362			`volatile A va;`
363			`const volatile A cva;`
364			`sa t1;`
365			`sa t6;`
366			`sa t7;`
367			`return 0;`
368			`}`
369
370			`one sink_3_168( A&);`
371			`six sink_3_168(const A&&);`
372			`eight sink_3_168(const volatile A&&);`
373
374			`int test3_168()`
375			`{`
376			`A a;`
377			`const A ca;`
378			`volatile A va;`
379			`const volatile A cva;`
380			`sa t1;`
381			`sa t5;`
382			`sa t6;`
383			`sa t7;`
384			`sa t8;`
385			`return 0;`
386			`}`
387
388			`one sink_3_178( A&);`
389			`seven sink_3_178(volatile A&&);`
390			`eight sink_3_178(const volatile A&&);`
391
392			`int test3_178()`
393			`{`
394			`A a;`
395			`const A ca;`
396			`volatile A va;`
397			`const volatile A cva;`
398			`sa t1;`
399			`sa t5;`
400			`sa t6;`
401			`sa t7;`
402			`sa t8;`
403			`return 0;`
404			`}`
405
406			`two sink_3_234(const A&);`
407			`three sink_3_234(volatile A&);`
408			`four sink_3_234(const volatile A&);`
409
410			`int test3_234()`
411			`{`
412			`A a;`
413			`const A ca;`
414			`volatile A va;`
415			`const volatile A cva;`
416			`sa t2;`
417			`sa t3;`
418			`sa t4;`
419			`sa t5;`
420			`sa t6;`
421			`return 0;`
422			`}`
423
424			`two sink_3_235(const A&);`
425			`three sink_3_235(volatile A&);`
426			`five sink_3_235( A&&);`
427
428			`int test3_235()`
429			`{`
430			`A a;`
431			`const A ca;`
432			`volatile A va;`
433			`const volatile A cva;`
434			`sa t2;`
435			`sa t3;`
436			`sa t5;`
437			`sa t6;`
438			`return 0;`
439			`}`
440
441			`two sink_3_236(const A&);`
442			`three sink_3_236(volatile A&);`
443			`six sink_3_236(const A&&);`
444
445			`int test3_236()`
446			`{`
447			`A a;`
448			`const A ca;`
449			`volatile A va;`
450			`const volatile A cva;`
451			`sa t2;`
452			`sa t3;`
453			`sa t5;`
454			`sa t6;`
455			`return 0;`
456			`}`
457
458			`two sink_3_237(const A&);`
459			`three sink_3_237(volatile A&);`
460			`seven sink_3_237(volatile A&&);`
461
462			`int test3_237()`
463			`{`
464			`A a;`
465			`const A ca;`
466			`volatile A va;`
467			`const volatile A cva;`
468			`sa t2;`
469			`sa t3;`
470			`sa t5;`
471			`sa t6;`
472			`sa t7;`
473			`return 0;`
474			`}`
475
476			`two sink_3_238(const A&);`
477			`three sink_3_238(volatile A&);`
478			`eight sink_3_238(const volatile A&&);`
479
480			`int test3_238()`
481			`{`
482			`A a;`
483			`const A ca;`
484			`volatile A va;`
485			`const volatile A cva;`
486			`sa t2;`
487			`sa t3;`
488			`sa t5;`
489			`sa t6;`
490			`sa t7;`
491			`sa t8;`
492			`return 0;`
493			`}`
494
495			`two sink_3_245(const A&);`
496			`four sink_3_245(const volatile A&);`
497			`five sink_3_245( A&&);`
498
499			`int test3_245()`
500			`{`
501			`A a;`
502			`const A ca;`
503			`volatile A va;`
504			`const volatile A cva;`
505			`sa t1;`
506			`sa t2;`
507			`sa t3;`
508			`sa t4;`
509			`sa t5;`
510			`sa t6;`
511			`return 0;`
512			`}`
513
514			`two sink_3_246(const A&);`
515			`four sink_3_246(const volatile A&);`
516			`six sink_3_246(const A&&);`
517
518			`int test3_246()`
519			`{`
520			`A a;`
521			`const A ca;`
522			`volatile A va;`
523			`const volatile A cva;`
524			`sa t1;`
525			`sa t2;`
526			`sa t3;`
527			`sa t4;`
528			`sa t5;`
529			`sa t6;`
530			`return 0;`
531			`}`
532
533			`two sink_3_247(const A&);`
534			`four sink_3_247(const volatile A&);`
535			`seven sink_3_247(volatile A&&);`
536
537			`int test3_247()`
538			`{`
539			`A a;`
540			`const A ca;`
541			`volatile A va;`
542			`const volatile A cva;`
543			`sa t1;`
544			`sa t2;`
545			`sa t3;`
546			`sa t4;`
547			`sa t5;`
548			`sa t6;`
549			`sa t7;`
550			`return 0;`
551			`}`
552
553			`two sink_3_248(const A&);`
554			`four sink_3_248(const volatile A&);`
555			`eight sink_3_248(const volatile A&&);`
556
557			`int test3_248()`
558			`{`
559			`A a;`
560			`const A ca;`
561			`volatile A va;`
562			`const volatile A cva;`
563			`sa t1;`
564			`sa t2;`
565			`sa t3;`
566			`sa t4;`
567			`sa t5;`
568			`sa t6;`
569			`sa t7;`
570			`sa t8;`
571			`return 0;`
572			`}`
573
574			`two sink_3_256(const A&);`
575			`five sink_3_256( A&&);`
576			`six sink_3_256(const A&&);`
577
578			`int test3_256()`
579			`{`
580			`A a;`
581			`const A ca;`
582			`volatile A va;`
583			`const volatile A cva;`
584			`sa t1;`
585			`sa t2;`
586			`sa t5;`
587			`sa t6;`
588			`return 0;`
589			`}`
590
591			`two sink_3_257(const A&);`
592			`five sink_3_257( A&&);`
593			`seven sink_3_257(volatile A&&);`
594
595			`int test3_257()`
596			`{`
597			`A a;`
598			`const A ca;`
599			`volatile A va;`
600			`const volatile A cva;`
601			`sa t1;`
602			`sa t2;`
603			`sa t5;`
604			`sa t6;`
605			`sa t7;`
606			`return 0;`
607			`}`
608
609			`two sink_3_258(const A&);`
610			`five sink_3_258( A&&);`
611			`eight sink_3_258(const volatile A&&);`
612
613			`int test3_258()`
614			`{`
615			`A a;`
616			`const A ca;`
617			`volatile A va;`
618			`const volatile A cva;`
619			`sa t1;`
620			`sa t2;`
621			`sa t5;`
622			`sa t6;`
623			`sa t7;`
624			`sa t8;`
625			`return 0;`
626			`}`
627
628			`two sink_3_267(const A&);`
629			`six sink_3_267(const A&&);`
630			`seven sink_3_267(volatile A&&);`
631
632			`int test3_267()`
633			`{`
634			`A a;`
635			`const A ca;`
636			`volatile A va;`
637			`const volatile A cva;`
638			`sa t1;`
639			`sa t2;`
640			`sa t6;`
641			`sa t7;`
642			`return 0;`
643			`}`
644
645			`two sink_3_268(const A&);`
646			`six sink_3_268(const A&&);`
647			`eight sink_3_268(const volatile A&&);`
648
649			`int test3_268()`
650			`{`
651			`A a;`
652			`const A ca;`
653			`volatile A va;`
654			`const volatile A cva;`
655			`sa t1;`
656			`sa t2;`
657			`sa t5;`
658			`sa t6;`
659			`sa t7;`
660			`sa t8;`
661			`return 0;`
662			`}`
663
664			`two sink_3_278(const A&);`
665			`seven sink_3_278(volatile A&&);`
666			`eight sink_3_278(const volatile A&&);`
667
668			`int test3_278()`
669			`{`
670			`A a;`
671			`const A ca;`
672			`volatile A va;`
673			`const volatile A cva;`
674			`sa t1;`
675			`sa t2;`
676			`sa t5;`
677			`sa t6;`
678			`sa t7;`
679			`sa t8;`
680			`return 0;`
681			`}`
682
683			`three sink_3_345(volatile A&);`
684			`four sink_3_345(const volatile A&);`
685			`five sink_3_345( A&&);`
686
687			`int test3_345()`
688			`{`
689			`A a;`
690			`const A ca;`
691			`volatile A va;`
692			`const volatile A cva;`
693			`sa t1;`
694			`sa t2;`
695			`sa t3;`
696			`sa t4;`
697			`sa t5;`
698			`return 0;`
699			`}`
700
701			`three sink_3_346(volatile A&);`
702			`four sink_3_346(const volatile A&);`
703			`six sink_3_346(const A&&);`
704
705			`int test3_346()`
706			`{`
707			`A a;`
708			`const A ca;`
709			`volatile A va;`
710			`const volatile A cva;`
711			`sa t1;`
712			`sa t2;`
713			`sa t3;`
714			`sa t4;`
715			`sa t5;`
716			`sa t6;`
717			`return 0;`
718			`}`
719
720			`three sink_3_347(volatile A&);`
721			`four sink_3_347(const volatile A&);`
722			`seven sink_3_347(volatile A&&);`
723
724			`int test3_347()`
725			`{`
726			`A a;`
727			`const A ca;`
728			`volatile A va;`
729			`const volatile A cva;`
730			`sa t1;`
731			`sa t2;`
732			`sa t3;`
733			`sa t4;`
734			`sa t5;`
735			`sa t7;`
736			`return 0;`
737			`}`
738
739			`three sink_3_348(volatile A&);`
740			`four sink_3_348(const volatile A&);`
741			`eight sink_3_348(const volatile A&&);`
742
743			`int test3_348()`
744			`{`
745			`A a;`
746			`const A ca;`
747			`volatile A va;`
748			`const volatile A cva;`
749			`sa t1;`
750			`sa t2;`
751			`sa t3;`
752			`sa t4;`
753			`sa t5;`
754			`sa t6;`
755			`sa t7;`
756			`sa t8;`
757			`return 0;`
758			`}`
759
760			`three sink_3_356(volatile A&);`
761			`five sink_3_356( A&&);`
762			`six sink_3_356(const A&&);`
763
764			`int test3_356()`
765			`{`
766			`A a;`
767			`const A ca;`
768			`volatile A va;`
769			`const volatile A cva;`
770			`sa t1;`
771			`sa t3;`
772			`sa t5;`
773			`sa t6;`
774			`return 0;`
775			`}`
776
777			`three sink_3_357(volatile A&);`
778			`five sink_3_357( A&&);`
779			`seven sink_3_357(volatile A&&);`
780
781			`int test3_357()`
782			`{`
783			`A a;`
784			`const A ca;`
785			`volatile A va;`
786			`const volatile A cva;`
787			`sa t1;`
788			`sa t3;`
789			`sa t5;`
790			`sa t7;`
791			`return 0;`
792			`}`
793
794			`three sink_3_358(volatile A&);`
795			`five sink_3_358( A&&);`
796			`eight sink_3_358(const volatile A&&);`
797
798			`int test3_358()`
799			`{`
800			`A a;`
801			`const A ca;`
802			`volatile A va;`
803			`const volatile A cva;`
804			`sa t1;`
805			`sa t3;`
806			`sa t5;`
807			`sa t6;`
808			`sa t7;`
809			`sa t8;`
810			`return 0;`
811			`}`
812
813			`three sink_3_367(volatile A&);`
814			`six sink_3_367(const A&&);`
815			`seven sink_3_367(volatile A&&);`
816
817			`int test3_367()`
818			`{`
819			`A a;`
820			`const A ca;`
821			`volatile A va;`
822			`const volatile A cva;`
823			`sa t1;`
824			`sa t3;`
825			`sa t6;`
826			`sa t7;`
827			`return 0;`
828			`}`
829
830			`three sink_3_368(volatile A&);`
831			`six sink_3_368(const A&&);`
832			`eight sink_3_368(const volatile A&&);`
833
834			`int test3_368()`
835			`{`
836			`A a;`
837			`const A ca;`
838			`volatile A va;`
839			`const volatile A cva;`
840			`sa t1;`
841			`sa t3;`
842			`sa t5;`
843			`sa t6;`
844			`sa t7;`
845			`sa t8;`
846			`return 0;`
847			`}`
848
849			`three sink_3_378(volatile A&);`
850			`seven sink_3_378(volatile A&&);`
851			`eight sink_3_378(const volatile A&&);`
852
853			`int test3_378()`
854			`{`
855			`A a;`
856			`const A ca;`
857			`volatile A va;`
858			`const volatile A cva;`
859			`sa t1;`
860			`sa t3;`
861			`sa t5;`
862			`sa t6;`
863			`sa t7;`
864			`sa t8;`
865			`return 0;`
866			`}`
867
868			`four sink_3_456(const volatile A&);`
869			`five sink_3_456( A&&);`
870			`six sink_3_456(const A&&);`
871
872			`int test3_456()`
873			`{`
874			`A a;`
875			`const A ca;`
876			`volatile A va;`
877			`const volatile A cva;`
878			`sa t1;`
879			`sa t2;`
880			`sa t3;`
881			`sa t4;`
882			`sa t5;`
883			`sa t6;`
884			`return 0;`
885			`}`
886
887			`four sink_3_457(const volatile A&);`
888			`five sink_3_457( A&&);`
889			`seven sink_3_457(volatile A&&);`
890
891			`int test3_457()`
892			`{`
893			`A a;`
894			`const A ca;`
895			`volatile A va;`
896			`const volatile A cva;`
897			`sa t1;`
898			`sa t2;`
899			`sa t3;`
900			`sa t4;`
901			`sa t5;`
902			`sa t7;`
903			`return 0;`
904			`}`
905
906			`four sink_3_458(const volatile A&);`
907			`five sink_3_458( A&&);`
908			`eight sink_3_458(const volatile A&&);`
909
910			`int test3_458()`
911			`{`
912			`A a;`
913			`const A ca;`
914			`volatile A va;`
915			`const volatile A cva;`
916			`sa t1;`
917			`sa t2;`
918			`sa t3;`
919			`sa t4;`
920			`sa t5;`
921			`sa t6;`
922			`sa t7;`
923			`sa t8;`
924			`return 0;`
925			`}`
926
927			`four sink_3_467(const volatile A&);`
928			`six sink_3_467(const A&&);`
929			`seven sink_3_467(volatile A&&);`
930
931			`int test3_467()`
932			`{`
933			`A a;`
934			`const A ca;`
935			`volatile A va;`
936			`const volatile A cva;`
937			`sa t1;`
938			`sa t2;`
939			`sa t3;`
940			`sa t4;`
941			`sa t6;`
942			`sa t7;`
943			`return 0;`
944			`}`
945
946			`four sink_3_468(const volatile A&);`
947			`six sink_3_468(const A&&);`
948			`eight sink_3_468(const volatile A&&);`
949
950			`int test3_468()`
951			`{`
952			`A a;`
953			`const A ca;`
954			`volatile A va;`
955			`const volatile A cva;`
956			`sa t1;`
957			`sa t2;`
958			`sa t3;`
959			`sa t4;`
960			`sa t5;`
961			`sa t6;`
962			`sa t7;`
963			`sa t8;`
964			`return 0;`
965			`}`
966
967			`four sink_3_478(const volatile A&);`
968			`seven sink_3_478(volatile A&&);`
969			`eight sink_3_478(const volatile A&&);`
970
971			`int test3_478()`
972			`{`
973			`A a;`
974			`const A ca;`
975			`volatile A va;`
976			`const volatile A cva;`
977			`sa t1;`
978			`sa t2;`
979			`sa t3;`
980			`sa t4;`
981			`sa t5;`
982			`sa t6;`
983			`sa t7;`
984			`sa t8;`
985			`return 0;`
986			`}`
987
988			`five sink_3_567( A&&);`
989			`six sink_3_567(const A&&);`
990			`seven sink_3_567(volatile A&&);`
991
992			`int test3_567()`
993			`{`
994			`A a;`
995			`const A ca;`
996			`volatile A va;`
997			`const volatile A cva;`
998			`sa t5;`
999			`sa t6;`
1000			`sa t7;`
1001			`return 0;`
1002			`}`
1003
1004			`five sink_3_568( A&&);`
1005			`six sink_3_568(const A&&);`
1006			`eight sink_3_568(const volatile A&&);`
1007
1008			`int test3_568()`
1009			`{`
1010			`A a;`
1011			`const A ca;`
1012			`volatile A va;`
1013			`const volatile A cva;`
1014			`sa t5;`
1015			`sa t6;`
1016			`sa t7;`
1017			`sa t8;`
1018			`return 0;`
1019			`}`
1020
1021			`five sink_3_578( A&&);`
1022			`seven sink_3_578(volatile A&&);`
1023			`eight sink_3_578(const volatile A&&);`
1024
1025			`int test3_578()`
1026			`{`
1027			`A a;`
1028			`const A ca;`
1029			`volatile A va;`
1030			`const volatile A cva;`
1031			`sa t5;`
1032			`sa t6;`
1033			`sa t7;`
1034			`sa t8;`
1035			`return 0;`
1036			`}`
1037
1038			`six sink_3_678(const A&&);`
1039			`seven sink_3_678(volatile A&&);`
1040			`eight sink_3_678(const volatile A&&);`
1041
1042			`int test3_678()`
1043			`{`
1044			`A a;`
1045			`const A ca;`
1046			`volatile A va;`
1047			`const volatile A cva;`
1048			`sa t6;`
1049			`sa t7;`
1050			`sa t8;`
1051			`return 0;`
1052			`}`
1053
1054			`int main()`
1055			`{`
1056			`return test3_123() + test3_124() + test3_125() + test3_126() +`
1057			`test3_127() + test3_128() + test3_134() + test3_135() +`
1058			`test3_136() + test3_137() + test3_138() + test3_145() +`
1059			`test3_146() + test3_147() + test3_148() + test3_156() +`
1060			`test3_157() + test3_158() + test3_167() + test3_168() +`
1061			`test3_178() + test3_234() + test3_235() + test3_236() +`
1062			`test3_237() + test3_238() + test3_245() + test3_246() +`
1063			`test3_247() + test3_248() + test3_256() + test3_257() +`
1064			`test3_258() + test3_267() + test3_268() + test3_278() +`
1065			`test3_345() + test3_346() + test3_347() + test3_348() +`
1066			`test3_356() + test3_357() + test3_358() + test3_367() +`
1067			`test3_368() + test3_378() + test3_456() + test3_457() +`
1068			`test3_458() + test3_467() + test3_468() + test3_478() +`
1069			`test3_567() + test3_568() + test3_578() + test3_678();`
1070			`}`