[gcc] GCC 4.5.0=>4.5.1

gcc/gcc/testsuite/g++.dg/cpp0x/rv4p.C

 // I, Howard Hinnant, hereby place this code in the public domain.
 
-// Test overlaod resolution among referece types
+// Test overload resolution among reference types
 
 // { dg-do compile }
 // { dg-options "-std=c++0x" }
 
 template <bool> struct sa;
 template <> struct sa<true> {};
 
 struct one   {char x[1];};
 struct two   {char x[2];};
 struct three {char x[3];};
@@ skipping 101 matching lines @@
 
 int test4_1238()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_1238(a))           == 1> t1;
     sa<sizeof(sink_4_1238(ca))          == 2> t2;
     sa<sizeof(sink_4_1238(va))          == 3> t3;
-    sa<sizeof(sink_4_1238(cva))         == 8> t4;
     sa<sizeof(sink_4_1238(source()))    == 8> t5;
     sa<sizeof(sink_4_1238(c_source()))  == 8> t6;
     sa<sizeof(sink_4_1238(v_source()))  == 8> t7;
     sa<sizeof(sink_4_1238(cv_source())) == 8> t8;
     return 0;
 }
 
 one   sink_4_1245(               A&);
 two   sink_4_1245(const          A&);
 four  sink_4_1245(const volatile A&);
@@ skipping 101 matching lines @@
 seven sink_4_1257(volatile       A&&);
 
 int test4_1257()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_1257(a))           == 1> t1;
     sa<sizeof(sink_4_1257(ca))          == 2> t2;
-    sa<sizeof(sink_4_1257(va))          == 7> t3;
     sa<sizeof(sink_4_1257(source()))    == 5> t5;
     sa<sizeof(sink_4_1257(c_source()))  == 2> t6;
     sa<sizeof(sink_4_1257(v_source()))  == 7> t7;
     return 0;
 }
 
 one   sink_4_1258(               A&);
 two   sink_4_1258(const          A&);
 five  sink_4_1258(               A&&);
 eight sink_4_1258(const volatile A&&);
 
 int test4_1258()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_1258(a))           == 1> t1;
     sa<sizeof(sink_4_1258(ca))          == 2> t2;
-    sa<sizeof(sink_4_1258(va))          == 8> t3;
-    sa<sizeof(sink_4_1258(cva))         == 8> t4;
     sa<sizeof(sink_4_1258(source()))    == 5> t5;
     sa<sizeof(sink_4_1258(c_source()))  == 8> t6;
     sa<sizeof(sink_4_1258(v_source()))  == 8> t7;
     sa<sizeof(sink_4_1258(cv_source())) == 8> t8;
     return 0;
 }
 
 one   sink_4_1267(               A&);
 two   sink_4_1267(const          A&);
 six   sink_4_1267(const          A&&);
 seven sink_4_1267(volatile       A&&);
 
 int test4_1267()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_1267(a))           == 1> t1;
     sa<sizeof(sink_4_1267(ca))          == 2> t2;
-    sa<sizeof(sink_4_1267(va))          == 7> t3;
     sa<sizeof(sink_4_1267(c_source()))  == 6> t6;
     sa<sizeof(sink_4_1267(v_source()))  == 7> t7;
     return 0;
 }
 
 one   sink_4_1268(               A&);
 two   sink_4_1268(const          A&);
 six   sink_4_1268(const          A&&);
 eight sink_4_1268(const volatile A&&);
 
 int test4_1268()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_1268(a))           == 1> t1;
     sa<sizeof(sink_4_1268(ca))          == 2> t2;
-    sa<sizeof(sink_4_1268(va))          == 8> t3;
-    sa<sizeof(sink_4_1268(cva))         == 8> t4;
     sa<sizeof(sink_4_1268(source()))    == 6> t5;
     sa<sizeof(sink_4_1268(c_source()))  == 6> t6;
     sa<sizeof(sink_4_1268(v_source()))  == 8> t7;
     sa<sizeof(sink_4_1268(cv_source())) == 8> t8;
     return 0;
 }
 
 one   sink_4_1278(               A&);
 two   sink_4_1278(const          A&);
 seven sink_4_1278(volatile       A&&);
 eight sink_4_1278(const volatile A&&);
 
 int test4_1278()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_1278(a))           == 1> t1;
     sa<sizeof(sink_4_1278(ca))          == 2> t2;
-    sa<sizeof(sink_4_1278(va))          == 7> t3;
-    sa<sizeof(sink_4_1278(cva))         == 8> t4;
     sa<sizeof(sink_4_1278(source()))    == 7> t5;
     sa<sizeof(sink_4_1278(c_source()))  == 8> t6;
     sa<sizeof(sink_4_1278(v_source()))  == 7> t7;
     sa<sizeof(sink_4_1278(cv_source())) == 8> t8;
     return 0;
 }
 
 one   sink_4_1345(               A&);
 three sink_4_1345(volatile       A&);
 four  sink_4_1345(const volatile A&);
@@ skipping 80 matching lines @@
 five  sink_4_1356(               A&&);
 six   sink_4_1356(const          A&&);
 
 int test4_1356()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_1356(a))           == 1> t1;
-    sa<sizeof(sink_4_1356(ca))          == 6> t2;
     sa<sizeof(sink_4_1356(va))          == 3> t3;
     sa<sizeof(sink_4_1356(source()))    == 5> t5;
     sa<sizeof(sink_4_1356(c_source()))  == 6> t6;
     return 0;
 }
 
 one   sink_4_1357(               A&);
 three sink_4_1357(volatile       A&);
 five  sink_4_1357(               A&&);
 seven sink_4_1357(volatile       A&&);
@@ skipping 16 matching lines @@
 five  sink_4_1358(               A&&);
 eight sink_4_1358(const volatile A&&);
 
 int test4_1358()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_1358(a))           == 1> t1;
-    sa<sizeof(sink_4_1358(ca))          == 8> t2;
     sa<sizeof(sink_4_1358(va))          == 3> t3;
-    sa<sizeof(sink_4_1358(cva))         == 8> t4;
     sa<sizeof(sink_4_1358(source()))    == 5> t5;
     sa<sizeof(sink_4_1358(c_source()))  == 8> t6;
     sa<sizeof(sink_4_1358(v_source()))  == 8> t7;
     sa<sizeof(sink_4_1358(cv_source())) == 8> t8;
     return 0;
 }
 
 one   sink_4_1367(               A&);
 three sink_4_1367(volatile       A&);
 six   sink_4_1367(const          A&&);
 seven sink_4_1367(volatile       A&&);
 
 int test4_1367()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_1367(a))           == 1> t1;
-    sa<sizeof(sink_4_1367(ca))          == 6> t2;
     sa<sizeof(sink_4_1367(va))          == 3> t3;
     sa<sizeof(sink_4_1367(c_source()))  == 6> t6;
     sa<sizeof(sink_4_1367(v_source()))  == 7> t7;
     return 0;
 }
 
 one   sink_4_1368(               A&);
 three sink_4_1368(volatile       A&);
 six   sink_4_1368(const          A&&);
 eight sink_4_1368(const volatile A&&);
 
 int test4_1368()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_1368(a))           == 1> t1;
-    sa<sizeof(sink_4_1368(ca))          == 6> t2;
     sa<sizeof(sink_4_1368(va))          == 3> t3;
-    sa<sizeof(sink_4_1368(cva))         == 8> t4;
     sa<sizeof(sink_4_1368(source()))    == 6> t5;
     sa<sizeof(sink_4_1368(c_source()))  == 6> t6;
     sa<sizeof(sink_4_1368(v_source()))  == 8> t7;
     sa<sizeof(sink_4_1368(cv_source())) == 8> t8;
     return 0;
 }
 
 one   sink_4_1378(               A&);
 three sink_4_1378(volatile       A&);
 seven sink_4_1378(volatile       A&&);
 eight sink_4_1378(const volatile A&&);
 
 int test4_1378()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_1378(a))           == 1> t1;
-    sa<sizeof(sink_4_1378(ca))          == 8> t2;
     sa<sizeof(sink_4_1378(va))          == 3> t3;
-    sa<sizeof(sink_4_1378(cva))         == 8> t4;
     sa<sizeof(sink_4_1378(source()))    == 7> t5;
     sa<sizeof(sink_4_1378(c_source()))  == 8> t6;
     sa<sizeof(sink_4_1378(v_source()))  == 7> t7;
     sa<sizeof(sink_4_1378(cv_source())) == 8> t8;
     return 0;
 }
 
 one   sink_4_1456(               A&);
 four  sink_4_1456(const volatile A&);
 five  sink_4_1456(               A&&);
@@ skipping 125 matching lines @@
 six   sink_4_1567(const          A&&);
 seven sink_4_1567(volatile       A&&);
 
 int test4_1567()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_1567(a))           == 1> t1;
-    sa<sizeof(sink_4_1567(ca))          == 6> t2;
-    sa<sizeof(sink_4_1567(va))          == 7> t3;
     sa<sizeof(sink_4_1567(source()))    == 5> t5;
     sa<sizeof(sink_4_1567(c_source()))  == 6> t6;
     sa<sizeof(sink_4_1567(v_source()))  == 7> t7;
     return 0;
 }
 
 one   sink_4_1568(               A&);
 five  sink_4_1568(               A&&);
 six   sink_4_1568(const          A&&);
 eight sink_4_1568(const volatile A&&);
 
 int test4_1568()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_1568(a))           == 1> t1;
-    sa<sizeof(sink_4_1568(ca))          == 6> t2;
-    sa<sizeof(sink_4_1568(va))          == 8> t3;
-    sa<sizeof(sink_4_1568(cva))         == 8> t4;
     sa<sizeof(sink_4_1568(source()))    == 5> t5;
     sa<sizeof(sink_4_1568(c_source()))  == 6> t6;
     sa<sizeof(sink_4_1568(v_source()))  == 8> t7;
     sa<sizeof(sink_4_1568(cv_source())) == 8> t8;
     return 0;
 }
 
 one   sink_4_1578(               A&);
 five  sink_4_1578(               A&&);
 seven sink_4_1578(volatile       A&&);
 eight sink_4_1578(const volatile A&&);
 
 int test4_1578()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_1578(a))           == 1> t1;
-    sa<sizeof(sink_4_1578(ca))          == 8> t2;
-    sa<sizeof(sink_4_1578(va))          == 7> t3;
-    sa<sizeof(sink_4_1578(cva))         == 8> t4;
     sa<sizeof(sink_4_1578(source()))    == 5> t5;
     sa<sizeof(sink_4_1578(c_source()))  == 8> t6;
     sa<sizeof(sink_4_1578(v_source()))  == 7> t7;
     sa<sizeof(sink_4_1578(cv_source())) == 8> t8;
     return 0;
 }
 
 one   sink_4_1678(               A&);
 six   sink_4_1678(const          A&&);
 seven sink_4_1678(volatile       A&&);
 eight sink_4_1678(const volatile A&&);
 
 int test4_1678()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_1678(a))           == 1> t1;
-    sa<sizeof(sink_4_1678(ca))          == 6> t2;
-    sa<sizeof(sink_4_1678(va))          == 7> t3;
-    sa<sizeof(sink_4_1678(cva))         == 8> t4;
     sa<sizeof(sink_4_1678(c_source()))  == 6> t6;
     sa<sizeof(sink_4_1678(v_source()))  == 7> t7;
     sa<sizeof(sink_4_1678(cv_source())) == 8> t8;
     return 0;
 }
 
 two   sink_4_2345(const          A&);
 three sink_4_2345(volatile       A&);
 four  sink_4_2345(const volatile A&);
 five  sink_4_2345(               A&&);
@@ skipping 115 matching lines @@
 eight sink_4_2358(const volatile A&&);
 
 int test4_2358()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_2358(ca))          == 2> t2;
     sa<sizeof(sink_4_2358(va))          == 3> t3;
-    sa<sizeof(sink_4_2358(cva))         == 8> t4;
     sa<sizeof(sink_4_2358(source()))    == 5> t5;
     sa<sizeof(sink_4_2358(c_source()))  == 8> t6;
     sa<sizeof(sink_4_2358(v_source()))  == 8> t7;
     sa<sizeof(sink_4_2358(cv_source())) == 8> t8;
     return 0;
 }
 
 two   sink_4_2367(const          A&);
 three sink_4_2367(volatile       A&);
 six   sink_4_2367(const          A&&);
@@ skipping 18 matching lines @@
 eight sink_4_2368(const volatile A&&);
 
 int test4_2368()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_2368(ca))          == 2> t2;
     sa<sizeof(sink_4_2368(va))          == 3> t3;
-    sa<sizeof(sink_4_2368(cva))         == 8> t4;
     sa<sizeof(sink_4_2368(source()))    == 6> t5;
     sa<sizeof(sink_4_2368(c_source()))  == 6> t6;
     sa<sizeof(sink_4_2368(v_source()))  == 8> t7;
     sa<sizeof(sink_4_2368(cv_source())) == 8> t8;
     return 0;
 }
 
 two   sink_4_2378(const          A&);
 three sink_4_2378(volatile       A&);
 seven sink_4_2378(volatile       A&&);
 eight sink_4_2378(const volatile A&&);
 
 int test4_2378()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_2378(ca))          == 2> t2;
     sa<sizeof(sink_4_2378(va))          == 3> t3;
-    sa<sizeof(sink_4_2378(cva))         == 8> t4;
     sa<sizeof(sink_4_2378(source()))    == 7> t5;
     sa<sizeof(sink_4_2378(c_source()))  == 8> t6;
     sa<sizeof(sink_4_2378(v_source()))  == 7> t7;
     sa<sizeof(sink_4_2378(cv_source())) == 8> t8;
     return 0;
 }
 
 two   sink_4_2456(const          A&);
 four  sink_4_2456(const volatile A&);
 five  sink_4_2456(               A&&);
@@ skipping 127 matching lines @@
 seven sink_4_2567(volatile       A&&);
 
 int test4_2567()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_2567(a))           == 2> t1;
     sa<sizeof(sink_4_2567(ca))          == 2> t2;
-    sa<sizeof(sink_4_2567(va))          == 7> t3;
     sa<sizeof(sink_4_2567(source()))    == 5> t5;
     sa<sizeof(sink_4_2567(c_source()))  == 6> t6;
     sa<sizeof(sink_4_2567(v_source()))  == 7> t7;
     return 0;
 }
 
 two   sink_4_2568(const          A&);
 five  sink_4_2568(               A&&);
 six   sink_4_2568(const          A&&);
 eight sink_4_2568(const volatile A&&);
 
 int test4_2568()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_2568(a))           == 2> t1;
     sa<sizeof(sink_4_2568(ca))          == 2> t2;
-    sa<sizeof(sink_4_2568(va))          == 8> t3;
-    sa<sizeof(sink_4_2568(cva))         == 8> t4;
     sa<sizeof(sink_4_2568(source()))    == 5> t5;
     sa<sizeof(sink_4_2568(c_source()))  == 6> t6;
     sa<sizeof(sink_4_2568(v_source()))  == 8> t7;
     sa<sizeof(sink_4_2568(cv_source())) == 8> t8;
     return 0;
 }
 
 two   sink_4_2578(const          A&);
 five  sink_4_2578(               A&&);
 seven sink_4_2578(volatile       A&&);
 eight sink_4_2578(const volatile A&&);
 
 int test4_2578()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_2578(a))           == 2> t1;
     sa<sizeof(sink_4_2578(ca))          == 2> t2;
-    sa<sizeof(sink_4_2578(va))          == 7> t3;
-    sa<sizeof(sink_4_2578(cva))         == 8> t4;
     sa<sizeof(sink_4_2578(source()))    == 5> t5;
     sa<sizeof(sink_4_2578(c_source()))  == 8> t6;
     sa<sizeof(sink_4_2578(v_source()))  == 7> t7;
     sa<sizeof(sink_4_2578(cv_source())) == 8> t8;
     return 0;
 }
 
 two   sink_4_2678(const          A&);
 six   sink_4_2678(const          A&&);
 seven sink_4_2678(volatile       A&&);
 eight sink_4_2678(const volatile A&&);
 
 int test4_2678()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_2678(a))           == 2> t1;
     sa<sizeof(sink_4_2678(ca))          == 2> t2;
-    sa<sizeof(sink_4_2678(va))          == 7> t3;
-    sa<sizeof(sink_4_2678(cva))         == 8> t4;
     sa<sizeof(sink_4_2678(c_source()))  == 6> t6;
     sa<sizeof(sink_4_2678(v_source()))  == 7> t7;
     sa<sizeof(sink_4_2678(cv_source())) == 8> t8;
     return 0;
 }
 
 three sink_4_3456(volatile       A&);
 four  sink_4_3456(const volatile A&);
 five  sink_4_3456(               A&&);
 six   sink_4_3456(const          A&&);
@@ skipping 124 matching lines @@
 six   sink_4_3567(const          A&&);
 seven sink_4_3567(volatile       A&&);
 
 int test4_3567()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_3567(a))           == 3> t1;
-    sa<sizeof(sink_4_3567(ca))          == 6> t2;
     sa<sizeof(sink_4_3567(va))          == 3> t3;
     sa<sizeof(sink_4_3567(source()))    == 5> t5;
     sa<sizeof(sink_4_3567(c_source()))  == 6> t6;
     sa<sizeof(sink_4_3567(v_source()))  == 7> t7;
     return 0;
 }
 
 three sink_4_3568(volatile       A&);
 five  sink_4_3568(               A&&);
 six   sink_4_3568(const          A&&);
 eight sink_4_3568(const volatile A&&);
 
 int test4_3568()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_3568(a))           == 3> t1;
-    sa<sizeof(sink_4_3568(ca))          == 6> t2;
     sa<sizeof(sink_4_3568(va))          == 3> t3;
-    sa<sizeof(sink_4_3568(cva))         == 8> t4;
     sa<sizeof(sink_4_3568(source()))    == 5> t5;
     sa<sizeof(sink_4_3568(c_source()))  == 6> t6;
     sa<sizeof(sink_4_3568(v_source()))  == 8> t7;
     sa<sizeof(sink_4_3568(cv_source())) == 8> t8;
     return 0;
 }
 
 three sink_4_3578(volatile       A&);
 five  sink_4_3578(               A&&);
 seven sink_4_3578(volatile       A&&);
 eight sink_4_3578(const volatile A&&);
 
 int test4_3578()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_3578(a))           == 3> t1;
-    sa<sizeof(sink_4_3578(ca))          == 8> t2;
     sa<sizeof(sink_4_3578(va))          == 3> t3;
-    sa<sizeof(sink_4_3578(cva))         == 8> t4;
     sa<sizeof(sink_4_3578(source()))    == 5> t5;
     sa<sizeof(sink_4_3578(c_source()))  == 8> t6;
     sa<sizeof(sink_4_3578(v_source()))  == 7> t7;
     sa<sizeof(sink_4_3578(cv_source())) == 8> t8;
     return 0;
 }
 
 three sink_4_3678(volatile       A&);
 six   sink_4_3678(const          A&&);
 seven sink_4_3678(volatile       A&&);
 eight sink_4_3678(const volatile A&&);
 
 int test4_3678()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
     sa<sizeof(sink_4_3678(a))           == 3> t1;
-    sa<sizeof(sink_4_3678(ca))          == 6> t2;
     sa<sizeof(sink_4_3678(va))          == 3> t3;
-    sa<sizeof(sink_4_3678(cva))         == 8> t4;
     sa<sizeof(sink_4_3678(c_source()))  == 6> t6;
     sa<sizeof(sink_4_3678(v_source()))  == 7> t7;
     sa<sizeof(sink_4_3678(cv_source())) == 8> t8;
     return 0;
 }
 
 four  sink_4_4567(const volatile A&);
 five  sink_4_4567(               A&&);
 six   sink_4_4567(const          A&&);
 seven sink_4_4567(volatile       A&&);
@@ skipping 83 matching lines @@
 six   sink_4_5678(const          A&&);
 seven sink_4_5678(volatile       A&&);
 eight sink_4_5678(const volatile A&&);
 
 int test4_5678()
 {
                    A a;
     const          A ca = a;
           volatile A va;
     const volatile A cva = a;
-    sa<sizeof(sink_4_5678(a))           == 5> t1;
-    sa<sizeof(sink_4_5678(ca))          == 6> t2;
-    sa<sizeof(sink_4_5678(va))          == 7> t3;
-    sa<sizeof(sink_4_5678(cva))         == 8> t4;
     sa<sizeof(sink_4_5678(source()))    == 5> t5;
     sa<sizeof(sink_4_5678(c_source()))  == 6> t6;
     sa<sizeof(sink_4_5678(v_source()))  == 7> t7;
     sa<sizeof(sink_4_5678(cv_source())) == 8> t8;
     return 0;
 }
 
 int main()
 {
     return test4_1234() + test4_1235() + test4_1236() + test4_1237() + test4_1238() +
            test4_1245() + test4_1246() + test4_1247() + test4_1248() + test4_1256() +
            test4_1257() + test4_1258() + test4_1267() + test4_1268() + test4_1278() +
            test4_1345() + test4_1346() + test4_1347() + test4_1348() + test4_1356() +
            test4_1357() + test4_1358() + test4_1367() + test4_1368() + test4_1378() +
            test4_1456() + test4_1457() + test4_1458() + test4_1467() + test4_1468() +
            test4_1478() + test4_1567() + test4_1568() + test4_1578() + test4_1678() +
            test4_2345() + test4_2346() + test4_2347() + test4_2348() + test4_2356() +
            test4_2357() + test4_2358() + test4_2367() + test4_2368() + test4_2378() +
            test4_2456() + test4_2457() + test4_2458() + test4_2467() + test4_2468() +
            test4_2478() + test4_2567() + test4_2568() + test4_2578() + test4_2678() +
            test4_3456() + test4_3457() + test4_3458() + test4_3467() + test4_3468() +
            test4_3478() + test4_3567() + test4_3568() + test4_3578() + test4_3678() +
            test4_4567() + test4_4568() + test4_4578() + test4_4678() + test4_5678();
 }