From 6ad26c222f4b9d1c7cc9e37414e8519131941c23 Mon Sep 17 00:00:00 2001 From: Matthias Maier Date: Tue, 20 Aug 2013 18:21:48 +0000 Subject: [PATCH] Reintroduce threads_0? tests git-svn-id: https://svn.dealii.org/branches/branch_port_the_testsuite@30360 0785d39b-7218-0410-832d-ea1e28bc413d --- tests/base/Makefile | 81 - tests/base/threads/threads.pl | 272 --- tests/base/threads_01.cc | 2080 ++++++++++++++++++++ tests/base/{threads => }/threads_01.output | 0 tests/base/threads_02.cc | 2080 ++++++++++++++++++++ tests/base/{threads => }/threads_02.output | 0 6 files changed, 4160 insertions(+), 353 deletions(-) delete mode 100644 tests/base/Makefile delete mode 100644 tests/base/threads/threads.pl create mode 100644 tests/base/threads_01.cc rename tests/base/{threads => }/threads_01.output (100%) create mode 100644 tests/base/threads_02.cc rename tests/base/{threads => }/threads_02.output (100%) diff --git a/tests/base/Makefile b/tests/base/Makefile deleted file mode 100644 index 1f4f76af06..0000000000 --- a/tests/base/Makefile +++ /dev/null @@ -1,81 +0,0 @@ -############################################################ -# $Id$ -# Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 by the deal.II authors -############################################################ - -############################################################ -# Include general settings for including DEAL libraries -############################################################ - -include ../Makefile.paths - -include $D/common/Make.global_options - - -default: run-tests - -############################################################ -# rules to generate the threading tests. the .cc files are -# automatically generated; note that for the output generation, we -# have to sort the output since otherwise in MT mode things would come -# out in a random order. the same holds for a few other tests -threads_01.cc : threads.pl - @echo =====regenerating== $@ - @$(PERL) $^ > $@ - -threads_02.cc : threads_01.cc - @echo =====regenerating== $@ - @cat $^ \ - | $(PERL) -pi -e 's/spawn \((.*), (.*)\) \(/new_thread (\2, \1, /g;' \ - | $(PERL) -pi -e 's/(new_thread.*), \)/\1)/g;' \ - | $(PERL) -pi -e 's/threads_01/threads_02/g;' \ - > $@ - -threads_%/output : threads_%/exe - @echo =====Running======= $< - @echo Running > $(dir $@)/status - @$(ULIMIT) -t 2400 ; ./$< ; \ - if test ! $$? = 0 ; then rm $@ ; false ; fi - @perl -pi $(normalize) $@ - @sort $@ -o $@ - -thread_validity_07/output : thread_validity_07/exe - @echo =====Running======= $< - @echo Running > $(dir $@)/status - @$(ULIMIT) -t 2400 ; ./$< ; \ - if test ! $$? = 0 ; then rm $@ ; false ; fi - @perl -pi $(normalize) $@ - @sort $@ -o $@ - -task_%/output : task_%/exe - @echo =====Running======= $< - @echo Running > $(dir $@)/status - @$(ULIMIT) -t 2400 ; ./$< ; \ - if test ! $$? = 0 ; then rm $@ ; false ; fi - @perl -pi $(normalize) $@ - @sort $@ -o $@ - - -############################################################ - -# all .cc-files are tests, though the test bdm.cc appears to be dysfunctional -# and we don't want the data_out_base_tecplot_bin test if we haven't found the -# corresponding libraries: -ifeq (, $(findstring tecio, $LIBS)) - tests = $(filter-out data_out_base_tecplot_bin, $(basename $(wildcard *.cc))) -else - tests = $(basename $(wildcard *.cc)) -endif - -# add threading tests. note that we have -# to list them individually, without wildcards, because the .cc files are -# generated and don't exist yet (so wildcard expansion will fail) -tests += threads_01 threads_02 - - -############################################################ - - -include ../Makefile.rules --include Makefile.depend --include Makefile.tests diff --git a/tests/base/threads/threads.pl b/tests/base/threads/threads.pl deleted file mode 100644 index 9289d75f71..0000000000 --- a/tests/base/threads/threads.pl +++ /dev/null @@ -1,272 +0,0 @@ -## --------------------------------------------------------------------- -## $Id$ -## -## Copyright (C) 2013 by the deal.II authors -## -## This file is part of the deal.II library. -## -## The deal.II library is free software; you can use it, redistribute -## it, and/or modify it under the terms of the GNU Lesser General -## Public License as published by the Free Software Foundation; either -## version 2.1 of the License, or (at your option) any later version. -## The full text of the license can be found in the file LICENSE at -## the top level of the deal.II distribution. -## -## --------------------------------------------------------------------- - -# This is the script with which threads_01.cc is generated -# -# The idea of the generated file is: have classes X which -# are not convertible into each other, and have functions with -# 0..9 arguments of types X<1>..X<9>, with reference and/or -# constant arguments, being virtual, static, or const. This way, -# we check all possible spawn(...) combinations and all possible -# combinations of arguments. Since the argument types are not -# convertible into each other, this also makes sure that there are -# no typos like "Arg4, Arg4" instead of "Arg4, Arg5", that might -# otherwise sneak in. - -$N=8; - -print "// This file is automatically generated by threads.pl. Don't modify it\n"; -print "#include \"../tests.h\"\n"; -print "#include \n"; -print "#include \n"; -print "#include \n"; -print "#include \n"; -print "template struct X {};\n"; -print "struct U {\n"; -print " virtual ~U () {}\n"; - - -sub print_args { - my $i = $_[0]; - my $pre = $_[1]; - my $post = $_[2]; - my $end = $_[3]; - for (my $j=1; $j<=$i; ++$j) { - print $pre, $j, $post, ($j!=$i ? "," : ""); - } - print ")${end} { \n"; - print " deallog << __PRETTY_FUNCTION__ << std::endl;\n"; - print " static X<0> x; return x;\n"; - print " }\n"; -} - -for ($i=0; $i<=$N; ++$i) { - print " X<0> foo_$i ("; - print_args ($i, "X<", ">", ""); - - print " static X<0> static_foo_$i ("; - print_args ($i, "X<", ">", ""); - - print " X<0> & ref_foo_$i ("; - print_args ($i, "X<", ">", ""); - - print " static X<0> & static_ref_foo_$i ("; - print_args ($i, "X<", ">", ""); - - print " static const X<0> & static_const_ref_foo_$i ("; - print_args ($i, "X<", ">", ""); - - print " X<0> foo_ref_$i ("; - print_args ($i, "X<", ">&", ""); - - print " static X<0> static_foo_ref_$i ("; - print_args ($i, "X<", ">&", ""); - - print " X<0> & ref_foo_ref_$i ("; - print_args ($i, "X<", ">&", ""); - - print " const X<0> & const_ref_foo_$i ("; - print_args ($i, "X<", ">", ""); - - print " const X<0> & const_ref_foo_ref_$i ("; - print_args ($i, "X<", ">&", ""); - - print " const X<0> & const_ref_foo_const_ref_$i ("; - print_args ($i, "X<", ">&", ""); - - print " const X<0> & const_ref_foo_${i}_const ("; - print_args ($i, "X<", ">", "const"); - - print " const X<0> & const_ref_foo_ref_${i}_const ("; - print_args ($i, "X<", ">&", "const"); - - print " const X<0> & const_ref_foo_const_ref_${i}_const ("; - print_args ($i, "X<", ">&", "const"); - - print " virtual const X<0> & virtual_const_ref_foo_$i ("; - print_args ($i, "X<", ">", ""); - - print " virtual const X<0> & virtual_const_ref_foo_ref_$i ("; - print_args ($i, "X<", ">&", ""); - - print " virtual const X<0> & virtual_const_ref_foo_const_ref_$i ("; - print_args ($i, "X<", ">&", ""); - - print " virtual const X<0> & virtual_const_ref_foo_${i}_const ("; - print_args ($i, "X<", ">", "const"); - - print " virtual const X<0> & virtual_const_ref_foo_ref_${i}_const ("; - print_args ($i, "X<", ">&", "const"); - - print " virtual const X<0> & virtual_const_ref_foo_const_ref_${i}_const ("; - print_args ($i, "X<", ">&", "const"); - - print " static X<0> & static_ref_foo_ref_$i ("; - print_args ($i, "X<", ">&", ""); - - print " static const X<0> & static_const_ref_foo_ref_$i ("; - print_args ($i, "X<", ">&", ""); - - print " X<0> foo_const_ref_$i ("; - print_args ($i, "const X<", ">&", ""); - - print " static X<0> static_foo_const_ref_$i ("; - print_args ($i, "const X<", ">&", ""); - - print " X<0> & ref_foo_const_ref_$i ("; - print_args ($i, "const X<", ">&", ""); - - print " static X<0> & static_ref_foo_const_ref_$i ("; - print_args ($i, "const X<", ">&", ""); - - print " static const X<0> & static_const_ref_foo_const_ref_$i ("; - print_args ($i, "const X<", ">&", ""); - - print " X<0> foo_${i}_const ("; - print_args ($i, "X<", ">", " const"); - - print " X<0> & ref_foo_${i}_const ("; - print_args ($i, "X<", ">", " const"); - - print " X<0> foo_ref_${i}_const ("; - print_args ($i, "X<", ">&", " const"); - - print " X<0> & ref_foo_ref_${i}_const ("; - print_args ($i, "X<", ">&", " const"); - - print " X<0> foo_const_ref_${i}_const ("; - print_args ($i, "const X<", ">&", " const"); - - print " X<0> & ref_foo_const_ref_${i}_const ("; - print_args ($i, "const X<", ">&", " const"); - - print " virtual X<0> virtual_foo_${i}_const ("; - print_args ($i, "X<", ">", " const"); - - print " virtual X<0> & virtual_ref_foo_${i}_const ("; - print_args ($i, "X<", ">", " const"); - - print " virtual X<0> virtual_foo_ref_${i}_const ("; - print_args ($i, "X<", ">&", " const"); - - print " virtual X<0> & virtual_ref_foo_ref_${i}_const ("; - print_args ($i, "X<", ">&", " const"); - - print " virtual X<0> virtual_foo_const_ref_${i}_const ("; - print_args ($i, "const X<", ">&", " const"); - - print " virtual X<0> & virtual_ref_foo_const_ref_${i}_const ("; - print_args ($i, "const X<", ">&", " const"); - - print " virtual X<0> virtual_foo_$i ("; - print_args ($i, "X<", ">", ""); - - print " virtual X<0> & virtual_ref_foo_$i ("; - print_args ($i, "X<", ">", ""); - - print " virtual X<0> virtual_foo_ref_$i ("; - print_args ($i, "X<", ">&", ""); - - print " virtual X<0> & virtual_ref_foo_ref_$i ("; - print_args ($i, "X<", ">&", ""); - - print " virtual X<0> virtual_foo_const_ref_$i ("; - print_args ($i, "const X<", ">&", ""); - - print " virtual X<0> & virtual_ref_foo_const_ref_$i ("; - print_args ($i, "const X<", ">&", ""); -} - -print "};\n"; - - -print "int main () {\n"; -print " std::ofstream logfile(\"threads_01/output\");\n"; -print " deallog.attach(logfile);\n"; -print " deallog.depth_console(0);\n"; - -print " using namespace Threads;\n"; -print " ThreadGroup > tg;\n"; -print " ThreadGroup&> tgr;\n"; -print " ThreadGroup&> tgcr;\n"; -print " U u;\n"; -for ($i=1; $i<=$N; ++$i) { - print "X<$i> x$i;\n"; -} -for ($i=0; $i<=$N; ++$i) { - $arglist = "("; - for ($j=1; $j<=$i; ++$j) { - $arglist = $arglist . "x$j" . ($j!=$i ? "," : ""); - } - $arglist = $arglist . ")"; - -#### where are the const ref functions?? - print << "END" - tgr += spawn (u, &U::ref_foo_${i}) $arglist; - tgr += spawn (u, &U::ref_foo_${i}_const) $arglist; - tgr += spawn (u, &U::ref_foo_const_ref_${i}) $arglist; - tgr += spawn (u, &U::ref_foo_const_ref_${i}_const) $arglist; - tgr += spawn (u, &U::ref_foo_ref_${i}) $arglist; - tgr += spawn (u, &U::ref_foo_ref_${i}_const) $arglist; - tgcr += spawn (u, &U::const_ref_foo_${i}) $arglist; - tgcr += spawn (u, &U::const_ref_foo_${i}_const) $arglist; - tgcr += spawn (u, &U::const_ref_foo_const_ref_${i}) $arglist; - tgcr += spawn (u, &U::const_ref_foo_const_ref_${i}_const) $arglist; - tgcr += spawn (u, &U::const_ref_foo_ref_${i}) $arglist; - tgcr += spawn (u, &U::const_ref_foo_ref_${i}_const) $arglist; - tgcr += spawn (u, &U::virtual_const_ref_foo_${i}) $arglist; - tgcr += spawn (u, &U::virtual_const_ref_foo_${i}_const) $arglist; - tgcr += spawn (u, &U::virtual_const_ref_foo_const_ref_${i}) $arglist; - tgcr += spawn (u, &U::virtual_const_ref_foo_const_ref_${i}_const) $arglist; - tgcr += spawn (u, &U::virtual_const_ref_foo_ref_${i}) $arglist; - tgcr += spawn (u, &U::virtual_const_ref_foo_ref_${i}_const) $arglist; - tg += spawn (u, &U::foo_${i}) $arglist; - tg += spawn (u, &U::foo_${i}_const) $arglist; - tg += spawn (u, &U::foo_const_ref_${i}) $arglist; - tg += spawn (u, &U::foo_const_ref_${i}_const) $arglist; - tg += spawn (u, &U::foo_ref_${i}) $arglist; - tg += spawn (u, &U::foo_ref_${i}_const) $arglist; - tgr += spawn (u, &U::virtual_ref_foo_${i}) $arglist; - tgr += spawn (u, &U::virtual_ref_foo_${i}_const) $arglist; - tgr += spawn (u, &U::virtual_ref_foo_const_ref_${i}) $arglist; - tgr += spawn (u, &U::virtual_ref_foo_const_ref_${i}_const) $arglist; - tgr += spawn (u, &U::virtual_ref_foo_ref_${i}) $arglist; - tgr += spawn (u, &U::virtual_ref_foo_ref_${i}_const) $arglist; - tg += spawn (u, &U::virtual_foo_${i}) $arglist; - tg += spawn (u, &U::virtual_foo_${i}_const) $arglist; - tg += spawn (u, &U::virtual_foo_const_ref_${i}) $arglist; - tg += spawn (u, &U::virtual_foo_const_ref_${i}_const) $arglist; - tg += spawn (u, &U::virtual_foo_ref_${i}) $arglist; - tg += spawn (u, &U::virtual_foo_ref_${i}_const) $arglist; - - tgr += spawn (&U::static_ref_foo_${i}) $arglist; - tgr += spawn (&U::static_ref_foo_const_ref_${i}) $arglist; - tgr += spawn (&U::static_ref_foo_ref_${i}) $arglist; - tgcr += spawn (&U::static_const_ref_foo_${i}) $arglist; - tgcr += spawn (&U::static_const_ref_foo_const_ref_${i}) $arglist; - tgcr += spawn (&U::static_const_ref_foo_ref_${i}) $arglist; - tg += spawn (&U::static_foo_${i}) $arglist; - tg += spawn (&U::static_foo_const_ref_${i}) $arglist; - tg += spawn (&U::static_foo_ref_${i}) $arglist; -END - ; -} -print " tg.join_all();\n"; -print " tgr.join_all();\n"; -print " tgcr.join_all();\n"; -print "}\n"; - -############# diff --git a/tests/base/threads_01.cc b/tests/base/threads_01.cc new file mode 100644 index 0000000000..3045c84a75 --- /dev/null +++ b/tests/base/threads_01.cc @@ -0,0 +1,2080 @@ +// --------------------------------------------------------------------- +// $Id$ +// +// Copyright (C) 2013 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + +#include "../tests.h" +#include +#include +#include +#include +template struct X {}; +struct U { + virtual ~U () {} + X<0> foo_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_0_const ()const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_0_const ()const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_0_const ()const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_0_const ()const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_0_const ()const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_0_const ()const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_const_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_const_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_const_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_1 (X<1>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_1 (X<1>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_1 (X<1>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_1 (X<1>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_1 (X<1>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_1 (X<1>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_1_const (X<1>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_1_const (X<1>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_1_const (X<1>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_1 (X<1>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_1_const (X<1>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_1_const (X<1>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_1_const (X<1>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_1 (const X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_const_ref_1 (const X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_1 (const X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_const_ref_1 (const X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_const_ref_1 (const X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_1_const (X<1>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_1_const (X<1>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_1_const (X<1>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_1_const (X<1>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_1_const (const X<1>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_1_const (const X<1>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_1_const (X<1>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_1_const (X<1>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_1_const (X<1>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_1_const (X<1>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_1_const (const X<1>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_1_const (const X<1>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_1 (X<1>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_1 (X<1>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_1 (const X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_1 (const X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_2 (X<1>,X<2>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_2 (X<1>,X<2>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_2 (X<1>,X<2>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_2 (X<1>,X<2>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_2 (X<1>,X<2>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_2 (X<1>,X<2>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_2_const (X<1>,X<2>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_2_const (X<1>&,X<2>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_2_const (X<1>&,X<2>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_2 (X<1>,X<2>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_2_const (X<1>,X<2>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_2_const (X<1>&,X<2>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_2_const (X<1>&,X<2>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_2 (const X<1>&,const X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_const_ref_2 (const X<1>&,const X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_2 (const X<1>&,const X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_const_ref_2 (const X<1>&,const X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_const_ref_2 (const X<1>&,const X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_2_const (X<1>,X<2>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_2_const (X<1>,X<2>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_2_const (X<1>&,X<2>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_2_const (X<1>&,X<2>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_2_const (const X<1>&,const X<2>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_2_const (const X<1>&,const X<2>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_2_const (X<1>,X<2>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_2_const (X<1>,X<2>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_2_const (X<1>&,X<2>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_2_const (X<1>&,X<2>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_2_const (const X<1>&,const X<2>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_2_const (const X<1>&,const X<2>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_2 (X<1>,X<2>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_2 (X<1>,X<2>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_2 (const X<1>&,const X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_2 (const X<1>&,const X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_3 (X<1>,X<2>,X<3>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_3 (X<1>,X<2>,X<3>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_3 (X<1>,X<2>,X<3>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_3 (X<1>,X<2>,X<3>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_3 (X<1>,X<2>,X<3>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_3 (X<1>,X<2>,X<3>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_3_const (X<1>,X<2>,X<3>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_3_const (X<1>&,X<2>&,X<3>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_3_const (X<1>&,X<2>&,X<3>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_3 (X<1>,X<2>,X<3>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_3_const (X<1>,X<2>,X<3>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_3_const (X<1>&,X<2>&,X<3>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_3_const (X<1>&,X<2>&,X<3>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_3 (const X<1>&,const X<2>&,const X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_const_ref_3 (const X<1>&,const X<2>&,const X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_3 (const X<1>&,const X<2>&,const X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_const_ref_3 (const X<1>&,const X<2>&,const X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_const_ref_3 (const X<1>&,const X<2>&,const X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_3_const (X<1>,X<2>,X<3>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_3_const (X<1>,X<2>,X<3>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_3_const (X<1>&,X<2>&,X<3>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_3_const (X<1>&,X<2>&,X<3>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_3_const (const X<1>&,const X<2>&,const X<3>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_3_const (const X<1>&,const X<2>&,const X<3>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_3_const (X<1>,X<2>,X<3>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_3_const (X<1>,X<2>,X<3>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_3_const (X<1>&,X<2>&,X<3>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_3_const (X<1>&,X<2>&,X<3>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_3_const (const X<1>&,const X<2>&,const X<3>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_3_const (const X<1>&,const X<2>&,const X<3>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_3 (X<1>,X<2>,X<3>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_3 (X<1>,X<2>,X<3>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_3 (const X<1>&,const X<2>&,const X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_3 (const X<1>&,const X<2>&,const X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_4 (X<1>,X<2>,X<3>,X<4>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_4 (X<1>,X<2>,X<3>,X<4>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_4 (X<1>,X<2>,X<3>,X<4>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_4 (X<1>,X<2>,X<3>,X<4>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_4 (X<1>,X<2>,X<3>,X<4>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_4 (X<1>,X<2>,X<3>,X<4>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_4_const (X<1>,X<2>,X<3>,X<4>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_4_const (X<1>&,X<2>&,X<3>&,X<4>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_4_const (X<1>&,X<2>&,X<3>&,X<4>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_4 (X<1>,X<2>,X<3>,X<4>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_4_const (X<1>,X<2>,X<3>,X<4>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_4_const (X<1>&,X<2>&,X<3>&,X<4>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_4_const (X<1>&,X<2>&,X<3>&,X<4>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_4 (const X<1>&,const X<2>&,const X<3>&,const X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_const_ref_4 (const X<1>&,const X<2>&,const X<3>&,const X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_4 (const X<1>&,const X<2>&,const X<3>&,const X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_const_ref_4 (const X<1>&,const X<2>&,const X<3>&,const X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_const_ref_4 (const X<1>&,const X<2>&,const X<3>&,const X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_4_const (X<1>,X<2>,X<3>,X<4>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_4_const (X<1>,X<2>,X<3>,X<4>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_4_const (X<1>&,X<2>&,X<3>&,X<4>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_4_const (X<1>&,X<2>&,X<3>&,X<4>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_4_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_4_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_4_const (X<1>,X<2>,X<3>,X<4>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_4_const (X<1>,X<2>,X<3>,X<4>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_4_const (X<1>&,X<2>&,X<3>&,X<4>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_4_const (X<1>&,X<2>&,X<3>&,X<4>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_4_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_4_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_4 (X<1>,X<2>,X<3>,X<4>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_4 (X<1>,X<2>,X<3>,X<4>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_4 (const X<1>&,const X<2>&,const X<3>&,const X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_4 (const X<1>&,const X<2>&,const X<3>&,const X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_5 (X<1>,X<2>,X<3>,X<4>,X<5>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_5 (X<1>,X<2>,X<3>,X<4>,X<5>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_5 (X<1>,X<2>,X<3>,X<4>,X<5>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_5 (X<1>,X<2>,X<3>,X<4>,X<5>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_5 (X<1>,X<2>,X<3>,X<4>,X<5>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_5 (X<1>,X<2>,X<3>,X<4>,X<5>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_5_const (X<1>,X<2>,X<3>,X<4>,X<5>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_5_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_5_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_5 (X<1>,X<2>,X<3>,X<4>,X<5>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_5_const (X<1>,X<2>,X<3>,X<4>,X<5>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_5_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_5_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_5 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_const_ref_5 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_5 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_const_ref_5 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_const_ref_5 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_5_const (X<1>,X<2>,X<3>,X<4>,X<5>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_5_const (X<1>,X<2>,X<3>,X<4>,X<5>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_5_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_5_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_5_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_5_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_5_const (X<1>,X<2>,X<3>,X<4>,X<5>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_5_const (X<1>,X<2>,X<3>,X<4>,X<5>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_5_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_5_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_5_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_5_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_5 (X<1>,X<2>,X<3>,X<4>,X<5>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_5 (X<1>,X<2>,X<3>,X<4>,X<5>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_5 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_5 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_6 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_6 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_6 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_6 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_6 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_6 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_6_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_6_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_6_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_6 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_6_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_6_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_6_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_6 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_const_ref_6 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_6 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_const_ref_6 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_const_ref_6 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_6_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_6_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_6_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_6_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_6_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_6_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_6_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_6_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_6_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_6_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_6_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_6_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_6 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_6 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_6 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_6 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_7 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_7 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_7 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_7 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_7 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_7 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_7_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_7_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_7_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_7 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_7_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_7_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_7_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_7 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_const_ref_7 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_7 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_const_ref_7 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_const_ref_7 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_7_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_7_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_7_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_7_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_7_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_7_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_7_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_7_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_7_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_7_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_7_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_7_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_7 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_7 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_7 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_7 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_8 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_8 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_8 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_8 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_8 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_8 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_8_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_8_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_8_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_8 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_8_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_8_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_8_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_8 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_const_ref_8 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_8 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_const_ref_8 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_const_ref_8 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_8_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_8_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_8_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_8_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_8_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_8_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_8_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_8_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_8_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_8_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_8_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_8_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_8 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_8 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_8 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_8 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } +}; +int main () { + std::ofstream logfile("output"); + deallog.attach(logfile); + deallog.depth_console(0); + using namespace Threads; + ThreadGroup > tg; + ThreadGroup&> tgr; + ThreadGroup&> tgcr; + U u; +X<1> x1; +X<2> x2; +X<3> x3; +X<4> x4; +X<5> x5; +X<6> x6; +X<7> x7; +X<8> x8; + tgr += spawn (u, &U::ref_foo_0) (); + tgr += spawn (u, &U::ref_foo_0_const) (); + tgr += spawn (u, &U::ref_foo_const_ref_0) (); + tgr += spawn (u, &U::ref_foo_const_ref_0_const) (); + tgr += spawn (u, &U::ref_foo_ref_0) (); + tgr += spawn (u, &U::ref_foo_ref_0_const) (); + tgcr += spawn (u, &U::const_ref_foo_0) (); + tgcr += spawn (u, &U::const_ref_foo_0_const) (); + tgcr += spawn (u, &U::const_ref_foo_const_ref_0) (); + tgcr += spawn (u, &U::const_ref_foo_const_ref_0_const) (); + tgcr += spawn (u, &U::const_ref_foo_ref_0) (); + tgcr += spawn (u, &U::const_ref_foo_ref_0_const) (); + tgcr += spawn (u, &U::virtual_const_ref_foo_0) (); + tgcr += spawn (u, &U::virtual_const_ref_foo_0_const) (); + tgcr += spawn (u, &U::virtual_const_ref_foo_const_ref_0) (); + tgcr += spawn (u, &U::virtual_const_ref_foo_const_ref_0_const) (); + tgcr += spawn (u, &U::virtual_const_ref_foo_ref_0) (); + tgcr += spawn (u, &U::virtual_const_ref_foo_ref_0_const) (); + tg += spawn (u, &U::foo_0) (); + tg += spawn (u, &U::foo_0_const) (); + tg += spawn (u, &U::foo_const_ref_0) (); + tg += spawn (u, &U::foo_const_ref_0_const) (); + tg += spawn (u, &U::foo_ref_0) (); + tg += spawn (u, &U::foo_ref_0_const) (); + tgr += spawn (u, &U::virtual_ref_foo_0) (); + tgr += spawn (u, &U::virtual_ref_foo_0_const) (); + tgr += spawn (u, &U::virtual_ref_foo_const_ref_0) (); + tgr += spawn (u, &U::virtual_ref_foo_const_ref_0_const) (); + tgr += spawn (u, &U::virtual_ref_foo_ref_0) (); + tgr += spawn (u, &U::virtual_ref_foo_ref_0_const) (); + tg += spawn (u, &U::virtual_foo_0) (); + tg += spawn (u, &U::virtual_foo_0_const) (); + tg += spawn (u, &U::virtual_foo_const_ref_0) (); + tg += spawn (u, &U::virtual_foo_const_ref_0_const) (); + tg += spawn (u, &U::virtual_foo_ref_0) (); + tg += spawn (u, &U::virtual_foo_ref_0_const) (); + + tgr += spawn (&U::static_ref_foo_0) (); + tgr += spawn (&U::static_ref_foo_const_ref_0) (); + tgr += spawn (&U::static_ref_foo_ref_0) (); + tgcr += spawn (&U::static_const_ref_foo_0) (); + tgcr += spawn (&U::static_const_ref_foo_const_ref_0) (); + tgcr += spawn (&U::static_const_ref_foo_ref_0) (); + tg += spawn (&U::static_foo_0) (); + tg += spawn (&U::static_foo_const_ref_0) (); + tg += spawn (&U::static_foo_ref_0) (); + tgr += spawn (u, &U::ref_foo_1) (x1); + tgr += spawn (u, &U::ref_foo_1_const) (x1); + tgr += spawn (u, &U::ref_foo_const_ref_1) (x1); + tgr += spawn (u, &U::ref_foo_const_ref_1_const) (x1); + tgr += spawn (u, &U::ref_foo_ref_1) (x1); + tgr += spawn (u, &U::ref_foo_ref_1_const) (x1); + tgcr += spawn (u, &U::const_ref_foo_1) (x1); + tgcr += spawn (u, &U::const_ref_foo_1_const) (x1); + tgcr += spawn (u, &U::const_ref_foo_const_ref_1) (x1); + tgcr += spawn (u, &U::const_ref_foo_const_ref_1_const) (x1); + tgcr += spawn (u, &U::const_ref_foo_ref_1) (x1); + tgcr += spawn (u, &U::const_ref_foo_ref_1_const) (x1); + tgcr += spawn (u, &U::virtual_const_ref_foo_1) (x1); + tgcr += spawn (u, &U::virtual_const_ref_foo_1_const) (x1); + tgcr += spawn (u, &U::virtual_const_ref_foo_const_ref_1) (x1); + tgcr += spawn (u, &U::virtual_const_ref_foo_const_ref_1_const) (x1); + tgcr += spawn (u, &U::virtual_const_ref_foo_ref_1) (x1); + tgcr += spawn (u, &U::virtual_const_ref_foo_ref_1_const) (x1); + tg += spawn (u, &U::foo_1) (x1); + tg += spawn (u, &U::foo_1_const) (x1); + tg += spawn (u, &U::foo_const_ref_1) (x1); + tg += spawn (u, &U::foo_const_ref_1_const) (x1); + tg += spawn (u, &U::foo_ref_1) (x1); + tg += spawn (u, &U::foo_ref_1_const) (x1); + tgr += spawn (u, &U::virtual_ref_foo_1) (x1); + tgr += spawn (u, &U::virtual_ref_foo_1_const) (x1); + tgr += spawn (u, &U::virtual_ref_foo_const_ref_1) (x1); + tgr += spawn (u, &U::virtual_ref_foo_const_ref_1_const) (x1); + tgr += spawn (u, &U::virtual_ref_foo_ref_1) (x1); + tgr += spawn (u, &U::virtual_ref_foo_ref_1_const) (x1); + tg += spawn (u, &U::virtual_foo_1) (x1); + tg += spawn (u, &U::virtual_foo_1_const) (x1); + tg += spawn (u, &U::virtual_foo_const_ref_1) (x1); + tg += spawn (u, &U::virtual_foo_const_ref_1_const) (x1); + tg += spawn (u, &U::virtual_foo_ref_1) (x1); + tg += spawn (u, &U::virtual_foo_ref_1_const) (x1); + + tgr += spawn (&U::static_ref_foo_1) (x1); + tgr += spawn (&U::static_ref_foo_const_ref_1) (x1); + tgr += spawn (&U::static_ref_foo_ref_1) (x1); + tgcr += spawn (&U::static_const_ref_foo_1) (x1); + tgcr += spawn (&U::static_const_ref_foo_const_ref_1) (x1); + tgcr += spawn (&U::static_const_ref_foo_ref_1) (x1); + tg += spawn (&U::static_foo_1) (x1); + tg += spawn (&U::static_foo_const_ref_1) (x1); + tg += spawn (&U::static_foo_ref_1) (x1); + tgr += spawn (u, &U::ref_foo_2) (x1,x2); + tgr += spawn (u, &U::ref_foo_2_const) (x1,x2); + tgr += spawn (u, &U::ref_foo_const_ref_2) (x1,x2); + tgr += spawn (u, &U::ref_foo_const_ref_2_const) (x1,x2); + tgr += spawn (u, &U::ref_foo_ref_2) (x1,x2); + tgr += spawn (u, &U::ref_foo_ref_2_const) (x1,x2); + tgcr += spawn (u, &U::const_ref_foo_2) (x1,x2); + tgcr += spawn (u, &U::const_ref_foo_2_const) (x1,x2); + tgcr += spawn (u, &U::const_ref_foo_const_ref_2) (x1,x2); + tgcr += spawn (u, &U::const_ref_foo_const_ref_2_const) (x1,x2); + tgcr += spawn (u, &U::const_ref_foo_ref_2) (x1,x2); + tgcr += spawn (u, &U::const_ref_foo_ref_2_const) (x1,x2); + tgcr += spawn (u, &U::virtual_const_ref_foo_2) (x1,x2); + tgcr += spawn (u, &U::virtual_const_ref_foo_2_const) (x1,x2); + tgcr += spawn (u, &U::virtual_const_ref_foo_const_ref_2) (x1,x2); + tgcr += spawn (u, &U::virtual_const_ref_foo_const_ref_2_const) (x1,x2); + tgcr += spawn (u, &U::virtual_const_ref_foo_ref_2) (x1,x2); + tgcr += spawn (u, &U::virtual_const_ref_foo_ref_2_const) (x1,x2); + tg += spawn (u, &U::foo_2) (x1,x2); + tg += spawn (u, &U::foo_2_const) (x1,x2); + tg += spawn (u, &U::foo_const_ref_2) (x1,x2); + tg += spawn (u, &U::foo_const_ref_2_const) (x1,x2); + tg += spawn (u, &U::foo_ref_2) (x1,x2); + tg += spawn (u, &U::foo_ref_2_const) (x1,x2); + tgr += spawn (u, &U::virtual_ref_foo_2) (x1,x2); + tgr += spawn (u, &U::virtual_ref_foo_2_const) (x1,x2); + tgr += spawn (u, &U::virtual_ref_foo_const_ref_2) (x1,x2); + tgr += spawn (u, &U::virtual_ref_foo_const_ref_2_const) (x1,x2); + tgr += spawn (u, &U::virtual_ref_foo_ref_2) (x1,x2); + tgr += spawn (u, &U::virtual_ref_foo_ref_2_const) (x1,x2); + tg += spawn (u, &U::virtual_foo_2) (x1,x2); + tg += spawn (u, &U::virtual_foo_2_const) (x1,x2); + tg += spawn (u, &U::virtual_foo_const_ref_2) (x1,x2); + tg += spawn (u, &U::virtual_foo_const_ref_2_const) (x1,x2); + tg += spawn (u, &U::virtual_foo_ref_2) (x1,x2); + tg += spawn (u, &U::virtual_foo_ref_2_const) (x1,x2); + + tgr += spawn (&U::static_ref_foo_2) (x1,x2); + tgr += spawn (&U::static_ref_foo_const_ref_2) (x1,x2); + tgr += spawn (&U::static_ref_foo_ref_2) (x1,x2); + tgcr += spawn (&U::static_const_ref_foo_2) (x1,x2); + tgcr += spawn (&U::static_const_ref_foo_const_ref_2) (x1,x2); + tgcr += spawn (&U::static_const_ref_foo_ref_2) (x1,x2); + tg += spawn (&U::static_foo_2) (x1,x2); + tg += spawn (&U::static_foo_const_ref_2) (x1,x2); + tg += spawn (&U::static_foo_ref_2) (x1,x2); + tgr += spawn (u, &U::ref_foo_3) (x1,x2,x3); + tgr += spawn (u, &U::ref_foo_3_const) (x1,x2,x3); + tgr += spawn (u, &U::ref_foo_const_ref_3) (x1,x2,x3); + tgr += spawn (u, &U::ref_foo_const_ref_3_const) (x1,x2,x3); + tgr += spawn (u, &U::ref_foo_ref_3) (x1,x2,x3); + tgr += spawn (u, &U::ref_foo_ref_3_const) (x1,x2,x3); + tgcr += spawn (u, &U::const_ref_foo_3) (x1,x2,x3); + tgcr += spawn (u, &U::const_ref_foo_3_const) (x1,x2,x3); + tgcr += spawn (u, &U::const_ref_foo_const_ref_3) (x1,x2,x3); + tgcr += spawn (u, &U::const_ref_foo_const_ref_3_const) (x1,x2,x3); + tgcr += spawn (u, &U::const_ref_foo_ref_3) (x1,x2,x3); + tgcr += spawn (u, &U::const_ref_foo_ref_3_const) (x1,x2,x3); + tgcr += spawn (u, &U::virtual_const_ref_foo_3) (x1,x2,x3); + tgcr += spawn (u, &U::virtual_const_ref_foo_3_const) (x1,x2,x3); + tgcr += spawn (u, &U::virtual_const_ref_foo_const_ref_3) (x1,x2,x3); + tgcr += spawn (u, &U::virtual_const_ref_foo_const_ref_3_const) (x1,x2,x3); + tgcr += spawn (u, &U::virtual_const_ref_foo_ref_3) (x1,x2,x3); + tgcr += spawn (u, &U::virtual_const_ref_foo_ref_3_const) (x1,x2,x3); + tg += spawn (u, &U::foo_3) (x1,x2,x3); + tg += spawn (u, &U::foo_3_const) (x1,x2,x3); + tg += spawn (u, &U::foo_const_ref_3) (x1,x2,x3); + tg += spawn (u, &U::foo_const_ref_3_const) (x1,x2,x3); + tg += spawn (u, &U::foo_ref_3) (x1,x2,x3); + tg += spawn (u, &U::foo_ref_3_const) (x1,x2,x3); + tgr += spawn (u, &U::virtual_ref_foo_3) (x1,x2,x3); + tgr += spawn (u, &U::virtual_ref_foo_3_const) (x1,x2,x3); + tgr += spawn (u, &U::virtual_ref_foo_const_ref_3) (x1,x2,x3); + tgr += spawn (u, &U::virtual_ref_foo_const_ref_3_const) (x1,x2,x3); + tgr += spawn (u, &U::virtual_ref_foo_ref_3) (x1,x2,x3); + tgr += spawn (u, &U::virtual_ref_foo_ref_3_const) (x1,x2,x3); + tg += spawn (u, &U::virtual_foo_3) (x1,x2,x3); + tg += spawn (u, &U::virtual_foo_3_const) (x1,x2,x3); + tg += spawn (u, &U::virtual_foo_const_ref_3) (x1,x2,x3); + tg += spawn (u, &U::virtual_foo_const_ref_3_const) (x1,x2,x3); + tg += spawn (u, &U::virtual_foo_ref_3) (x1,x2,x3); + tg += spawn (u, &U::virtual_foo_ref_3_const) (x1,x2,x3); + + tgr += spawn (&U::static_ref_foo_3) (x1,x2,x3); + tgr += spawn (&U::static_ref_foo_const_ref_3) (x1,x2,x3); + tgr += spawn (&U::static_ref_foo_ref_3) (x1,x2,x3); + tgcr += spawn (&U::static_const_ref_foo_3) (x1,x2,x3); + tgcr += spawn (&U::static_const_ref_foo_const_ref_3) (x1,x2,x3); + tgcr += spawn (&U::static_const_ref_foo_ref_3) (x1,x2,x3); + tg += spawn (&U::static_foo_3) (x1,x2,x3); + tg += spawn (&U::static_foo_const_ref_3) (x1,x2,x3); + tg += spawn (&U::static_foo_ref_3) (x1,x2,x3); + tgr += spawn (u, &U::ref_foo_4) (x1,x2,x3,x4); + tgr += spawn (u, &U::ref_foo_4_const) (x1,x2,x3,x4); + tgr += spawn (u, &U::ref_foo_const_ref_4) (x1,x2,x3,x4); + tgr += spawn (u, &U::ref_foo_const_ref_4_const) (x1,x2,x3,x4); + tgr += spawn (u, &U::ref_foo_ref_4) (x1,x2,x3,x4); + tgr += spawn (u, &U::ref_foo_ref_4_const) (x1,x2,x3,x4); + tgcr += spawn (u, &U::const_ref_foo_4) (x1,x2,x3,x4); + tgcr += spawn (u, &U::const_ref_foo_4_const) (x1,x2,x3,x4); + tgcr += spawn (u, &U::const_ref_foo_const_ref_4) (x1,x2,x3,x4); + tgcr += spawn (u, &U::const_ref_foo_const_ref_4_const) (x1,x2,x3,x4); + tgcr += spawn (u, &U::const_ref_foo_ref_4) (x1,x2,x3,x4); + tgcr += spawn (u, &U::const_ref_foo_ref_4_const) (x1,x2,x3,x4); + tgcr += spawn (u, &U::virtual_const_ref_foo_4) (x1,x2,x3,x4); + tgcr += spawn (u, &U::virtual_const_ref_foo_4_const) (x1,x2,x3,x4); + tgcr += spawn (u, &U::virtual_const_ref_foo_const_ref_4) (x1,x2,x3,x4); + tgcr += spawn (u, &U::virtual_const_ref_foo_const_ref_4_const) (x1,x2,x3,x4); + tgcr += spawn (u, &U::virtual_const_ref_foo_ref_4) (x1,x2,x3,x4); + tgcr += spawn (u, &U::virtual_const_ref_foo_ref_4_const) (x1,x2,x3,x4); + tg += spawn (u, &U::foo_4) (x1,x2,x3,x4); + tg += spawn (u, &U::foo_4_const) (x1,x2,x3,x4); + tg += spawn (u, &U::foo_const_ref_4) (x1,x2,x3,x4); + tg += spawn (u, &U::foo_const_ref_4_const) (x1,x2,x3,x4); + tg += spawn (u, &U::foo_ref_4) (x1,x2,x3,x4); + tg += spawn (u, &U::foo_ref_4_const) (x1,x2,x3,x4); + tgr += spawn (u, &U::virtual_ref_foo_4) (x1,x2,x3,x4); + tgr += spawn (u, &U::virtual_ref_foo_4_const) (x1,x2,x3,x4); + tgr += spawn (u, &U::virtual_ref_foo_const_ref_4) (x1,x2,x3,x4); + tgr += spawn (u, &U::virtual_ref_foo_const_ref_4_const) (x1,x2,x3,x4); + tgr += spawn (u, &U::virtual_ref_foo_ref_4) (x1,x2,x3,x4); + tgr += spawn (u, &U::virtual_ref_foo_ref_4_const) (x1,x2,x3,x4); + tg += spawn (u, &U::virtual_foo_4) (x1,x2,x3,x4); + tg += spawn (u, &U::virtual_foo_4_const) (x1,x2,x3,x4); + tg += spawn (u, &U::virtual_foo_const_ref_4) (x1,x2,x3,x4); + tg += spawn (u, &U::virtual_foo_const_ref_4_const) (x1,x2,x3,x4); + tg += spawn (u, &U::virtual_foo_ref_4) (x1,x2,x3,x4); + tg += spawn (u, &U::virtual_foo_ref_4_const) (x1,x2,x3,x4); + + tgr += spawn (&U::static_ref_foo_4) (x1,x2,x3,x4); + tgr += spawn (&U::static_ref_foo_const_ref_4) (x1,x2,x3,x4); + tgr += spawn (&U::static_ref_foo_ref_4) (x1,x2,x3,x4); + tgcr += spawn (&U::static_const_ref_foo_4) (x1,x2,x3,x4); + tgcr += spawn (&U::static_const_ref_foo_const_ref_4) (x1,x2,x3,x4); + tgcr += spawn (&U::static_const_ref_foo_ref_4) (x1,x2,x3,x4); + tg += spawn (&U::static_foo_4) (x1,x2,x3,x4); + tg += spawn (&U::static_foo_const_ref_4) (x1,x2,x3,x4); + tg += spawn (&U::static_foo_ref_4) (x1,x2,x3,x4); + tgr += spawn (u, &U::ref_foo_5) (x1,x2,x3,x4,x5); + tgr += spawn (u, &U::ref_foo_5_const) (x1,x2,x3,x4,x5); + tgr += spawn (u, &U::ref_foo_const_ref_5) (x1,x2,x3,x4,x5); + tgr += spawn (u, &U::ref_foo_const_ref_5_const) (x1,x2,x3,x4,x5); + tgr += spawn (u, &U::ref_foo_ref_5) (x1,x2,x3,x4,x5); + tgr += spawn (u, &U::ref_foo_ref_5_const) (x1,x2,x3,x4,x5); + tgcr += spawn (u, &U::const_ref_foo_5) (x1,x2,x3,x4,x5); + tgcr += spawn (u, &U::const_ref_foo_5_const) (x1,x2,x3,x4,x5); + tgcr += spawn (u, &U::const_ref_foo_const_ref_5) (x1,x2,x3,x4,x5); + tgcr += spawn (u, &U::const_ref_foo_const_ref_5_const) (x1,x2,x3,x4,x5); + tgcr += spawn (u, &U::const_ref_foo_ref_5) (x1,x2,x3,x4,x5); + tgcr += spawn (u, &U::const_ref_foo_ref_5_const) (x1,x2,x3,x4,x5); + tgcr += spawn (u, &U::virtual_const_ref_foo_5) (x1,x2,x3,x4,x5); + tgcr += spawn (u, &U::virtual_const_ref_foo_5_const) (x1,x2,x3,x4,x5); + tgcr += spawn (u, &U::virtual_const_ref_foo_const_ref_5) (x1,x2,x3,x4,x5); + tgcr += spawn (u, &U::virtual_const_ref_foo_const_ref_5_const) (x1,x2,x3,x4,x5); + tgcr += spawn (u, &U::virtual_const_ref_foo_ref_5) (x1,x2,x3,x4,x5); + tgcr += spawn (u, &U::virtual_const_ref_foo_ref_5_const) (x1,x2,x3,x4,x5); + tg += spawn (u, &U::foo_5) (x1,x2,x3,x4,x5); + tg += spawn (u, &U::foo_5_const) (x1,x2,x3,x4,x5); + tg += spawn (u, &U::foo_const_ref_5) (x1,x2,x3,x4,x5); + tg += spawn (u, &U::foo_const_ref_5_const) (x1,x2,x3,x4,x5); + tg += spawn (u, &U::foo_ref_5) (x1,x2,x3,x4,x5); + tg += spawn (u, &U::foo_ref_5_const) (x1,x2,x3,x4,x5); + tgr += spawn (u, &U::virtual_ref_foo_5) (x1,x2,x3,x4,x5); + tgr += spawn (u, &U::virtual_ref_foo_5_const) (x1,x2,x3,x4,x5); + tgr += spawn (u, &U::virtual_ref_foo_const_ref_5) (x1,x2,x3,x4,x5); + tgr += spawn (u, &U::virtual_ref_foo_const_ref_5_const) (x1,x2,x3,x4,x5); + tgr += spawn (u, &U::virtual_ref_foo_ref_5) (x1,x2,x3,x4,x5); + tgr += spawn (u, &U::virtual_ref_foo_ref_5_const) (x1,x2,x3,x4,x5); + tg += spawn (u, &U::virtual_foo_5) (x1,x2,x3,x4,x5); + tg += spawn (u, &U::virtual_foo_5_const) (x1,x2,x3,x4,x5); + tg += spawn (u, &U::virtual_foo_const_ref_5) (x1,x2,x3,x4,x5); + tg += spawn (u, &U::virtual_foo_const_ref_5_const) (x1,x2,x3,x4,x5); + tg += spawn (u, &U::virtual_foo_ref_5) (x1,x2,x3,x4,x5); + tg += spawn (u, &U::virtual_foo_ref_5_const) (x1,x2,x3,x4,x5); + + tgr += spawn (&U::static_ref_foo_5) (x1,x2,x3,x4,x5); + tgr += spawn (&U::static_ref_foo_const_ref_5) (x1,x2,x3,x4,x5); + tgr += spawn (&U::static_ref_foo_ref_5) (x1,x2,x3,x4,x5); + tgcr += spawn (&U::static_const_ref_foo_5) (x1,x2,x3,x4,x5); + tgcr += spawn (&U::static_const_ref_foo_const_ref_5) (x1,x2,x3,x4,x5); + tgcr += spawn (&U::static_const_ref_foo_ref_5) (x1,x2,x3,x4,x5); + tg += spawn (&U::static_foo_5) (x1,x2,x3,x4,x5); + tg += spawn (&U::static_foo_const_ref_5) (x1,x2,x3,x4,x5); + tg += spawn (&U::static_foo_ref_5) (x1,x2,x3,x4,x5); + tgr += spawn (u, &U::ref_foo_6) (x1,x2,x3,x4,x5,x6); + tgr += spawn (u, &U::ref_foo_6_const) (x1,x2,x3,x4,x5,x6); + tgr += spawn (u, &U::ref_foo_const_ref_6) (x1,x2,x3,x4,x5,x6); + tgr += spawn (u, &U::ref_foo_const_ref_6_const) (x1,x2,x3,x4,x5,x6); + tgr += spawn (u, &U::ref_foo_ref_6) (x1,x2,x3,x4,x5,x6); + tgr += spawn (u, &U::ref_foo_ref_6_const) (x1,x2,x3,x4,x5,x6); + tgcr += spawn (u, &U::const_ref_foo_6) (x1,x2,x3,x4,x5,x6); + tgcr += spawn (u, &U::const_ref_foo_6_const) (x1,x2,x3,x4,x5,x6); + tgcr += spawn (u, &U::const_ref_foo_const_ref_6) (x1,x2,x3,x4,x5,x6); + tgcr += spawn (u, &U::const_ref_foo_const_ref_6_const) (x1,x2,x3,x4,x5,x6); + tgcr += spawn (u, &U::const_ref_foo_ref_6) (x1,x2,x3,x4,x5,x6); + tgcr += spawn (u, &U::const_ref_foo_ref_6_const) (x1,x2,x3,x4,x5,x6); + tgcr += spawn (u, &U::virtual_const_ref_foo_6) (x1,x2,x3,x4,x5,x6); + tgcr += spawn (u, &U::virtual_const_ref_foo_6_const) (x1,x2,x3,x4,x5,x6); + tgcr += spawn (u, &U::virtual_const_ref_foo_const_ref_6) (x1,x2,x3,x4,x5,x6); + tgcr += spawn (u, &U::virtual_const_ref_foo_const_ref_6_const) (x1,x2,x3,x4,x5,x6); + tgcr += spawn (u, &U::virtual_const_ref_foo_ref_6) (x1,x2,x3,x4,x5,x6); + tgcr += spawn (u, &U::virtual_const_ref_foo_ref_6_const) (x1,x2,x3,x4,x5,x6); + tg += spawn (u, &U::foo_6) (x1,x2,x3,x4,x5,x6); + tg += spawn (u, &U::foo_6_const) (x1,x2,x3,x4,x5,x6); + tg += spawn (u, &U::foo_const_ref_6) (x1,x2,x3,x4,x5,x6); + tg += spawn (u, &U::foo_const_ref_6_const) (x1,x2,x3,x4,x5,x6); + tg += spawn (u, &U::foo_ref_6) (x1,x2,x3,x4,x5,x6); + tg += spawn (u, &U::foo_ref_6_const) (x1,x2,x3,x4,x5,x6); + tgr += spawn (u, &U::virtual_ref_foo_6) (x1,x2,x3,x4,x5,x6); + tgr += spawn (u, &U::virtual_ref_foo_6_const) (x1,x2,x3,x4,x5,x6); + tgr += spawn (u, &U::virtual_ref_foo_const_ref_6) (x1,x2,x3,x4,x5,x6); + tgr += spawn (u, &U::virtual_ref_foo_const_ref_6_const) (x1,x2,x3,x4,x5,x6); + tgr += spawn (u, &U::virtual_ref_foo_ref_6) (x1,x2,x3,x4,x5,x6); + tgr += spawn (u, &U::virtual_ref_foo_ref_6_const) (x1,x2,x3,x4,x5,x6); + tg += spawn (u, &U::virtual_foo_6) (x1,x2,x3,x4,x5,x6); + tg += spawn (u, &U::virtual_foo_6_const) (x1,x2,x3,x4,x5,x6); + tg += spawn (u, &U::virtual_foo_const_ref_6) (x1,x2,x3,x4,x5,x6); + tg += spawn (u, &U::virtual_foo_const_ref_6_const) (x1,x2,x3,x4,x5,x6); + tg += spawn (u, &U::virtual_foo_ref_6) (x1,x2,x3,x4,x5,x6); + tg += spawn (u, &U::virtual_foo_ref_6_const) (x1,x2,x3,x4,x5,x6); + + tgr += spawn (&U::static_ref_foo_6) (x1,x2,x3,x4,x5,x6); + tgr += spawn (&U::static_ref_foo_const_ref_6) (x1,x2,x3,x4,x5,x6); + tgr += spawn (&U::static_ref_foo_ref_6) (x1,x2,x3,x4,x5,x6); + tgcr += spawn (&U::static_const_ref_foo_6) (x1,x2,x3,x4,x5,x6); + tgcr += spawn (&U::static_const_ref_foo_const_ref_6) (x1,x2,x3,x4,x5,x6); + tgcr += spawn (&U::static_const_ref_foo_ref_6) (x1,x2,x3,x4,x5,x6); + tg += spawn (&U::static_foo_6) (x1,x2,x3,x4,x5,x6); + tg += spawn (&U::static_foo_const_ref_6) (x1,x2,x3,x4,x5,x6); + tg += spawn (&U::static_foo_ref_6) (x1,x2,x3,x4,x5,x6); + tgr += spawn (u, &U::ref_foo_7) (x1,x2,x3,x4,x5,x6,x7); + tgr += spawn (u, &U::ref_foo_7_const) (x1,x2,x3,x4,x5,x6,x7); + tgr += spawn (u, &U::ref_foo_const_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tgr += spawn (u, &U::ref_foo_const_ref_7_const) (x1,x2,x3,x4,x5,x6,x7); + tgr += spawn (u, &U::ref_foo_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tgr += spawn (u, &U::ref_foo_ref_7_const) (x1,x2,x3,x4,x5,x6,x7); + tgcr += spawn (u, &U::const_ref_foo_7) (x1,x2,x3,x4,x5,x6,x7); + tgcr += spawn (u, &U::const_ref_foo_7_const) (x1,x2,x3,x4,x5,x6,x7); + tgcr += spawn (u, &U::const_ref_foo_const_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tgcr += spawn (u, &U::const_ref_foo_const_ref_7_const) (x1,x2,x3,x4,x5,x6,x7); + tgcr += spawn (u, &U::const_ref_foo_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tgcr += spawn (u, &U::const_ref_foo_ref_7_const) (x1,x2,x3,x4,x5,x6,x7); + tgcr += spawn (u, &U::virtual_const_ref_foo_7) (x1,x2,x3,x4,x5,x6,x7); + tgcr += spawn (u, &U::virtual_const_ref_foo_7_const) (x1,x2,x3,x4,x5,x6,x7); + tgcr += spawn (u, &U::virtual_const_ref_foo_const_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tgcr += spawn (u, &U::virtual_const_ref_foo_const_ref_7_const) (x1,x2,x3,x4,x5,x6,x7); + tgcr += spawn (u, &U::virtual_const_ref_foo_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tgcr += spawn (u, &U::virtual_const_ref_foo_ref_7_const) (x1,x2,x3,x4,x5,x6,x7); + tg += spawn (u, &U::foo_7) (x1,x2,x3,x4,x5,x6,x7); + tg += spawn (u, &U::foo_7_const) (x1,x2,x3,x4,x5,x6,x7); + tg += spawn (u, &U::foo_const_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tg += spawn (u, &U::foo_const_ref_7_const) (x1,x2,x3,x4,x5,x6,x7); + tg += spawn (u, &U::foo_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tg += spawn (u, &U::foo_ref_7_const) (x1,x2,x3,x4,x5,x6,x7); + tgr += spawn (u, &U::virtual_ref_foo_7) (x1,x2,x3,x4,x5,x6,x7); + tgr += spawn (u, &U::virtual_ref_foo_7_const) (x1,x2,x3,x4,x5,x6,x7); + tgr += spawn (u, &U::virtual_ref_foo_const_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tgr += spawn (u, &U::virtual_ref_foo_const_ref_7_const) (x1,x2,x3,x4,x5,x6,x7); + tgr += spawn (u, &U::virtual_ref_foo_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tgr += spawn (u, &U::virtual_ref_foo_ref_7_const) (x1,x2,x3,x4,x5,x6,x7); + tg += spawn (u, &U::virtual_foo_7) (x1,x2,x3,x4,x5,x6,x7); + tg += spawn (u, &U::virtual_foo_7_const) (x1,x2,x3,x4,x5,x6,x7); + tg += spawn (u, &U::virtual_foo_const_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tg += spawn (u, &U::virtual_foo_const_ref_7_const) (x1,x2,x3,x4,x5,x6,x7); + tg += spawn (u, &U::virtual_foo_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tg += spawn (u, &U::virtual_foo_ref_7_const) (x1,x2,x3,x4,x5,x6,x7); + + tgr += spawn (&U::static_ref_foo_7) (x1,x2,x3,x4,x5,x6,x7); + tgr += spawn (&U::static_ref_foo_const_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tgr += spawn (&U::static_ref_foo_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tgcr += spawn (&U::static_const_ref_foo_7) (x1,x2,x3,x4,x5,x6,x7); + tgcr += spawn (&U::static_const_ref_foo_const_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tgcr += spawn (&U::static_const_ref_foo_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tg += spawn (&U::static_foo_7) (x1,x2,x3,x4,x5,x6,x7); + tg += spawn (&U::static_foo_const_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tg += spawn (&U::static_foo_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tgr += spawn (u, &U::ref_foo_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgr += spawn (u, &U::ref_foo_8_const) (x1,x2,x3,x4,x5,x6,x7,x8); + tgr += spawn (u, &U::ref_foo_const_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgr += spawn (u, &U::ref_foo_const_ref_8_const) (x1,x2,x3,x4,x5,x6,x7,x8); + tgr += spawn (u, &U::ref_foo_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgr += spawn (u, &U::ref_foo_ref_8_const) (x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += spawn (u, &U::const_ref_foo_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += spawn (u, &U::const_ref_foo_8_const) (x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += spawn (u, &U::const_ref_foo_const_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += spawn (u, &U::const_ref_foo_const_ref_8_const) (x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += spawn (u, &U::const_ref_foo_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += spawn (u, &U::const_ref_foo_ref_8_const) (x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += spawn (u, &U::virtual_const_ref_foo_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += spawn (u, &U::virtual_const_ref_foo_8_const) (x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += spawn (u, &U::virtual_const_ref_foo_const_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += spawn (u, &U::virtual_const_ref_foo_const_ref_8_const) (x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += spawn (u, &U::virtual_const_ref_foo_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += spawn (u, &U::virtual_const_ref_foo_ref_8_const) (x1,x2,x3,x4,x5,x6,x7,x8); + tg += spawn (u, &U::foo_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tg += spawn (u, &U::foo_8_const) (x1,x2,x3,x4,x5,x6,x7,x8); + tg += spawn (u, &U::foo_const_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tg += spawn (u, &U::foo_const_ref_8_const) (x1,x2,x3,x4,x5,x6,x7,x8); + tg += spawn (u, &U::foo_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tg += spawn (u, &U::foo_ref_8_const) (x1,x2,x3,x4,x5,x6,x7,x8); + tgr += spawn (u, &U::virtual_ref_foo_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgr += spawn (u, &U::virtual_ref_foo_8_const) (x1,x2,x3,x4,x5,x6,x7,x8); + tgr += spawn (u, &U::virtual_ref_foo_const_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgr += spawn (u, &U::virtual_ref_foo_const_ref_8_const) (x1,x2,x3,x4,x5,x6,x7,x8); + tgr += spawn (u, &U::virtual_ref_foo_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgr += spawn (u, &U::virtual_ref_foo_ref_8_const) (x1,x2,x3,x4,x5,x6,x7,x8); + tg += spawn (u, &U::virtual_foo_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tg += spawn (u, &U::virtual_foo_8_const) (x1,x2,x3,x4,x5,x6,x7,x8); + tg += spawn (u, &U::virtual_foo_const_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tg += spawn (u, &U::virtual_foo_const_ref_8_const) (x1,x2,x3,x4,x5,x6,x7,x8); + tg += spawn (u, &U::virtual_foo_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tg += spawn (u, &U::virtual_foo_ref_8_const) (x1,x2,x3,x4,x5,x6,x7,x8); + + tgr += spawn (&U::static_ref_foo_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgr += spawn (&U::static_ref_foo_const_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgr += spawn (&U::static_ref_foo_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += spawn (&U::static_const_ref_foo_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += spawn (&U::static_const_ref_foo_const_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += spawn (&U::static_const_ref_foo_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tg += spawn (&U::static_foo_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tg += spawn (&U::static_foo_const_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tg += spawn (&U::static_foo_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tg.join_all(); + tgr.join_all(); + tgcr.join_all(); +} diff --git a/tests/base/threads/threads_01.output b/tests/base/threads_01.output similarity index 100% rename from tests/base/threads/threads_01.output rename to tests/base/threads_01.output diff --git a/tests/base/threads_02.cc b/tests/base/threads_02.cc new file mode 100644 index 0000000000..7d1496c27f --- /dev/null +++ b/tests/base/threads_02.cc @@ -0,0 +1,2080 @@ +// --------------------------------------------------------------------- +// $Id$ +// +// Copyright (C) 2013 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE at +// the top level of the deal.II distribution. +// +// --------------------------------------------------------------------- + +#include "../tests.h" +#include +#include +#include +#include +template struct X {}; +struct U { + virtual ~U () {} + X<0> foo_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_0_const ()const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_0_const ()const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_0_const ()const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_0_const ()const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_0_const ()const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_0_const ()const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_const_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_const_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_const_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_0_const () const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_0 () { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_1 (X<1>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_1 (X<1>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_1 (X<1>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_1 (X<1>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_1 (X<1>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_1 (X<1>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_1_const (X<1>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_1_const (X<1>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_1_const (X<1>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_1 (X<1>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_1_const (X<1>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_1_const (X<1>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_1_const (X<1>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_1 (const X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_const_ref_1 (const X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_1 (const X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_const_ref_1 (const X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_const_ref_1 (const X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_1_const (X<1>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_1_const (X<1>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_1_const (X<1>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_1_const (X<1>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_1_const (const X<1>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_1_const (const X<1>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_1_const (X<1>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_1_const (X<1>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_1_const (X<1>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_1_const (X<1>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_1_const (const X<1>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_1_const (const X<1>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_1 (X<1>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_1 (X<1>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_1 (X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_1 (const X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_1 (const X<1>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_2 (X<1>,X<2>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_2 (X<1>,X<2>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_2 (X<1>,X<2>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_2 (X<1>,X<2>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_2 (X<1>,X<2>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_2 (X<1>,X<2>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_2_const (X<1>,X<2>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_2_const (X<1>&,X<2>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_2_const (X<1>&,X<2>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_2 (X<1>,X<2>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_2_const (X<1>,X<2>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_2_const (X<1>&,X<2>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_2_const (X<1>&,X<2>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_2 (const X<1>&,const X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_const_ref_2 (const X<1>&,const X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_2 (const X<1>&,const X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_const_ref_2 (const X<1>&,const X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_const_ref_2 (const X<1>&,const X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_2_const (X<1>,X<2>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_2_const (X<1>,X<2>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_2_const (X<1>&,X<2>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_2_const (X<1>&,X<2>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_2_const (const X<1>&,const X<2>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_2_const (const X<1>&,const X<2>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_2_const (X<1>,X<2>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_2_const (X<1>,X<2>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_2_const (X<1>&,X<2>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_2_const (X<1>&,X<2>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_2_const (const X<1>&,const X<2>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_2_const (const X<1>&,const X<2>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_2 (X<1>,X<2>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_2 (X<1>,X<2>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_2 (X<1>&,X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_2 (const X<1>&,const X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_2 (const X<1>&,const X<2>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_3 (X<1>,X<2>,X<3>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_3 (X<1>,X<2>,X<3>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_3 (X<1>,X<2>,X<3>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_3 (X<1>,X<2>,X<3>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_3 (X<1>,X<2>,X<3>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_3 (X<1>,X<2>,X<3>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_3_const (X<1>,X<2>,X<3>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_3_const (X<1>&,X<2>&,X<3>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_3_const (X<1>&,X<2>&,X<3>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_3 (X<1>,X<2>,X<3>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_3_const (X<1>,X<2>,X<3>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_3_const (X<1>&,X<2>&,X<3>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_3_const (X<1>&,X<2>&,X<3>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_3 (const X<1>&,const X<2>&,const X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_const_ref_3 (const X<1>&,const X<2>&,const X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_3 (const X<1>&,const X<2>&,const X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_const_ref_3 (const X<1>&,const X<2>&,const X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_const_ref_3 (const X<1>&,const X<2>&,const X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_3_const (X<1>,X<2>,X<3>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_3_const (X<1>,X<2>,X<3>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_3_const (X<1>&,X<2>&,X<3>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_3_const (X<1>&,X<2>&,X<3>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_3_const (const X<1>&,const X<2>&,const X<3>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_3_const (const X<1>&,const X<2>&,const X<3>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_3_const (X<1>,X<2>,X<3>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_3_const (X<1>,X<2>,X<3>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_3_const (X<1>&,X<2>&,X<3>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_3_const (X<1>&,X<2>&,X<3>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_3_const (const X<1>&,const X<2>&,const X<3>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_3_const (const X<1>&,const X<2>&,const X<3>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_3 (X<1>,X<2>,X<3>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_3 (X<1>,X<2>,X<3>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_3 (X<1>&,X<2>&,X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_3 (const X<1>&,const X<2>&,const X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_3 (const X<1>&,const X<2>&,const X<3>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_4 (X<1>,X<2>,X<3>,X<4>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_4 (X<1>,X<2>,X<3>,X<4>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_4 (X<1>,X<2>,X<3>,X<4>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_4 (X<1>,X<2>,X<3>,X<4>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_4 (X<1>,X<2>,X<3>,X<4>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_4 (X<1>,X<2>,X<3>,X<4>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_4_const (X<1>,X<2>,X<3>,X<4>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_4_const (X<1>&,X<2>&,X<3>&,X<4>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_4_const (X<1>&,X<2>&,X<3>&,X<4>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_4 (X<1>,X<2>,X<3>,X<4>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_4_const (X<1>,X<2>,X<3>,X<4>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_4_const (X<1>&,X<2>&,X<3>&,X<4>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_4_const (X<1>&,X<2>&,X<3>&,X<4>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_4 (const X<1>&,const X<2>&,const X<3>&,const X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_const_ref_4 (const X<1>&,const X<2>&,const X<3>&,const X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_4 (const X<1>&,const X<2>&,const X<3>&,const X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_const_ref_4 (const X<1>&,const X<2>&,const X<3>&,const X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_const_ref_4 (const X<1>&,const X<2>&,const X<3>&,const X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_4_const (X<1>,X<2>,X<3>,X<4>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_4_const (X<1>,X<2>,X<3>,X<4>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_4_const (X<1>&,X<2>&,X<3>&,X<4>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_4_const (X<1>&,X<2>&,X<3>&,X<4>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_4_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_4_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_4_const (X<1>,X<2>,X<3>,X<4>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_4_const (X<1>,X<2>,X<3>,X<4>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_4_const (X<1>&,X<2>&,X<3>&,X<4>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_4_const (X<1>&,X<2>&,X<3>&,X<4>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_4_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_4_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_4 (X<1>,X<2>,X<3>,X<4>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_4 (X<1>,X<2>,X<3>,X<4>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_4 (X<1>&,X<2>&,X<3>&,X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_4 (const X<1>&,const X<2>&,const X<3>&,const X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_4 (const X<1>&,const X<2>&,const X<3>&,const X<4>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_5 (X<1>,X<2>,X<3>,X<4>,X<5>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_5 (X<1>,X<2>,X<3>,X<4>,X<5>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_5 (X<1>,X<2>,X<3>,X<4>,X<5>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_5 (X<1>,X<2>,X<3>,X<4>,X<5>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_5 (X<1>,X<2>,X<3>,X<4>,X<5>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_5 (X<1>,X<2>,X<3>,X<4>,X<5>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_5_const (X<1>,X<2>,X<3>,X<4>,X<5>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_5_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_5_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_5 (X<1>,X<2>,X<3>,X<4>,X<5>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_5_const (X<1>,X<2>,X<3>,X<4>,X<5>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_5_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_5_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_5 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_const_ref_5 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_5 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_const_ref_5 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_const_ref_5 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_5_const (X<1>,X<2>,X<3>,X<4>,X<5>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_5_const (X<1>,X<2>,X<3>,X<4>,X<5>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_5_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_5_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_5_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_5_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_5_const (X<1>,X<2>,X<3>,X<4>,X<5>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_5_const (X<1>,X<2>,X<3>,X<4>,X<5>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_5_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_5_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_5_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_5_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_5 (X<1>,X<2>,X<3>,X<4>,X<5>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_5 (X<1>,X<2>,X<3>,X<4>,X<5>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_5 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_5 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_5 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_6 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_6 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_6 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_6 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_6 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_6 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_6_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_6_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_6_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_6 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_6_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_6_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_6_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_6 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_const_ref_6 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_6 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_const_ref_6 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_const_ref_6 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_6_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_6_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_6_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_6_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_6_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_6_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_6_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_6_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_6_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_6_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_6_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_6_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_6 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_6 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_6 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_6 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_6 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_7 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_7 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_7 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_7 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_7 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_7 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_7_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_7_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_7_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_7 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_7_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_7_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_7_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_7 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_const_ref_7 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_7 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_const_ref_7 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_const_ref_7 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_7_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_7_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_7_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_7_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_7_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_7_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_7_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_7_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_7_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_7_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_7_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_7_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_7 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_7 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_7 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_7 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_7 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_8 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_8 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_8 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_8 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_8 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_8 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_8_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_ref_8_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + const X<0> & const_ref_foo_const_ref_8_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_8 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_8_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_ref_8_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual const X<0> & virtual_const_ref_foo_const_ref_8_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&)const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_8 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> static_foo_const_ref_8 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_8 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static X<0> & static_ref_foo_const_ref_8 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + static const X<0> & static_const_ref_foo_const_ref_8 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_8_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_8_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_ref_8_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_ref_8_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> foo_const_ref_8_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + X<0> & ref_foo_const_ref_8_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_8_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_8_const (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_8_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_8_const (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_8_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_8_const (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) const { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_8 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_8 (X<1>,X<2>,X<3>,X<4>,X<5>,X<6>,X<7>,X<8>) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_ref_8 (X<1>&,X<2>&,X<3>&,X<4>&,X<5>&,X<6>&,X<7>&,X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> virtual_foo_const_ref_8 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } + virtual X<0> & virtual_ref_foo_const_ref_8 (const X<1>&,const X<2>&,const X<3>&,const X<4>&,const X<5>&,const X<6>&,const X<7>&,const X<8>&) { + deallog << __PRETTY_FUNCTION__ << std::endl; + static X<0> x; return x; + } +}; +int main () { + std::ofstream logfile("output"); + deallog.attach(logfile); + deallog.depth_console(0); + using namespace Threads; + ThreadGroup > tg; + ThreadGroup&> tgr; + ThreadGroup&> tgcr; + U u; +X<1> x1; +X<2> x2; +X<3> x3; +X<4> x4; +X<5> x5; +X<6> x6; +X<7> x7; +X<8> x8; + tgr += new_thread (&U::ref_foo_0, u); + tgr += new_thread (&U::ref_foo_0_const, u); + tgr += new_thread (&U::ref_foo_const_ref_0, u); + tgr += new_thread (&U::ref_foo_const_ref_0_const, u); + tgr += new_thread (&U::ref_foo_ref_0, u); + tgr += new_thread (&U::ref_foo_ref_0_const, u); + tgcr += new_thread (&U::const_ref_foo_0, u); + tgcr += new_thread (&U::const_ref_foo_0_const, u); + tgcr += new_thread (&U::const_ref_foo_const_ref_0, u); + tgcr += new_thread (&U::const_ref_foo_const_ref_0_const, u); + tgcr += new_thread (&U::const_ref_foo_ref_0, u); + tgcr += new_thread (&U::const_ref_foo_ref_0_const, u); + tgcr += new_thread (&U::virtual_const_ref_foo_0, u); + tgcr += new_thread (&U::virtual_const_ref_foo_0_const, u); + tgcr += new_thread (&U::virtual_const_ref_foo_const_ref_0, u); + tgcr += new_thread (&U::virtual_const_ref_foo_const_ref_0_const, u); + tgcr += new_thread (&U::virtual_const_ref_foo_ref_0, u); + tgcr += new_thread (&U::virtual_const_ref_foo_ref_0_const, u); + tg += new_thread (&U::foo_0, u); + tg += new_thread (&U::foo_0_const, u); + tg += new_thread (&U::foo_const_ref_0, u); + tg += new_thread (&U::foo_const_ref_0_const, u); + tg += new_thread (&U::foo_ref_0, u); + tg += new_thread (&U::foo_ref_0_const, u); + tgr += new_thread (&U::virtual_ref_foo_0, u); + tgr += new_thread (&U::virtual_ref_foo_0_const, u); + tgr += new_thread (&U::virtual_ref_foo_const_ref_0, u); + tgr += new_thread (&U::virtual_ref_foo_const_ref_0_const, u); + tgr += new_thread (&U::virtual_ref_foo_ref_0, u); + tgr += new_thread (&U::virtual_ref_foo_ref_0_const, u); + tg += new_thread (&U::virtual_foo_0, u); + tg += new_thread (&U::virtual_foo_0_const, u); + tg += new_thread (&U::virtual_foo_const_ref_0, u); + tg += new_thread (&U::virtual_foo_const_ref_0_const, u); + tg += new_thread (&U::virtual_foo_ref_0, u); + tg += new_thread (&U::virtual_foo_ref_0_const, u); + + tgr += spawn (&U::static_ref_foo_0) (); + tgr += spawn (&U::static_ref_foo_const_ref_0) (); + tgr += spawn (&U::static_ref_foo_ref_0) (); + tgcr += spawn (&U::static_const_ref_foo_0) (); + tgcr += spawn (&U::static_const_ref_foo_const_ref_0) (); + tgcr += spawn (&U::static_const_ref_foo_ref_0) (); + tg += spawn (&U::static_foo_0) (); + tg += spawn (&U::static_foo_const_ref_0) (); + tg += spawn (&U::static_foo_ref_0) (); + tgr += new_thread (&U::ref_foo_1, u, x1); + tgr += new_thread (&U::ref_foo_1_const, u, x1); + tgr += new_thread (&U::ref_foo_const_ref_1, u, x1); + tgr += new_thread (&U::ref_foo_const_ref_1_const, u, x1); + tgr += new_thread (&U::ref_foo_ref_1, u, x1); + tgr += new_thread (&U::ref_foo_ref_1_const, u, x1); + tgcr += new_thread (&U::const_ref_foo_1, u, x1); + tgcr += new_thread (&U::const_ref_foo_1_const, u, x1); + tgcr += new_thread (&U::const_ref_foo_const_ref_1, u, x1); + tgcr += new_thread (&U::const_ref_foo_const_ref_1_const, u, x1); + tgcr += new_thread (&U::const_ref_foo_ref_1, u, x1); + tgcr += new_thread (&U::const_ref_foo_ref_1_const, u, x1); + tgcr += new_thread (&U::virtual_const_ref_foo_1, u, x1); + tgcr += new_thread (&U::virtual_const_ref_foo_1_const, u, x1); + tgcr += new_thread (&U::virtual_const_ref_foo_const_ref_1, u, x1); + tgcr += new_thread (&U::virtual_const_ref_foo_const_ref_1_const, u, x1); + tgcr += new_thread (&U::virtual_const_ref_foo_ref_1, u, x1); + tgcr += new_thread (&U::virtual_const_ref_foo_ref_1_const, u, x1); + tg += new_thread (&U::foo_1, u, x1); + tg += new_thread (&U::foo_1_const, u, x1); + tg += new_thread (&U::foo_const_ref_1, u, x1); + tg += new_thread (&U::foo_const_ref_1_const, u, x1); + tg += new_thread (&U::foo_ref_1, u, x1); + tg += new_thread (&U::foo_ref_1_const, u, x1); + tgr += new_thread (&U::virtual_ref_foo_1, u, x1); + tgr += new_thread (&U::virtual_ref_foo_1_const, u, x1); + tgr += new_thread (&U::virtual_ref_foo_const_ref_1, u, x1); + tgr += new_thread (&U::virtual_ref_foo_const_ref_1_const, u, x1); + tgr += new_thread (&U::virtual_ref_foo_ref_1, u, x1); + tgr += new_thread (&U::virtual_ref_foo_ref_1_const, u, x1); + tg += new_thread (&U::virtual_foo_1, u, x1); + tg += new_thread (&U::virtual_foo_1_const, u, x1); + tg += new_thread (&U::virtual_foo_const_ref_1, u, x1); + tg += new_thread (&U::virtual_foo_const_ref_1_const, u, x1); + tg += new_thread (&U::virtual_foo_ref_1, u, x1); + tg += new_thread (&U::virtual_foo_ref_1_const, u, x1); + + tgr += spawn (&U::static_ref_foo_1) (x1); + tgr += spawn (&U::static_ref_foo_const_ref_1) (x1); + tgr += spawn (&U::static_ref_foo_ref_1) (x1); + tgcr += spawn (&U::static_const_ref_foo_1) (x1); + tgcr += spawn (&U::static_const_ref_foo_const_ref_1) (x1); + tgcr += spawn (&U::static_const_ref_foo_ref_1) (x1); + tg += spawn (&U::static_foo_1) (x1); + tg += spawn (&U::static_foo_const_ref_1) (x1); + tg += spawn (&U::static_foo_ref_1) (x1); + tgr += new_thread (&U::ref_foo_2, u, x1,x2); + tgr += new_thread (&U::ref_foo_2_const, u, x1,x2); + tgr += new_thread (&U::ref_foo_const_ref_2, u, x1,x2); + tgr += new_thread (&U::ref_foo_const_ref_2_const, u, x1,x2); + tgr += new_thread (&U::ref_foo_ref_2, u, x1,x2); + tgr += new_thread (&U::ref_foo_ref_2_const, u, x1,x2); + tgcr += new_thread (&U::const_ref_foo_2, u, x1,x2); + tgcr += new_thread (&U::const_ref_foo_2_const, u, x1,x2); + tgcr += new_thread (&U::const_ref_foo_const_ref_2, u, x1,x2); + tgcr += new_thread (&U::const_ref_foo_const_ref_2_const, u, x1,x2); + tgcr += new_thread (&U::const_ref_foo_ref_2, u, x1,x2); + tgcr += new_thread (&U::const_ref_foo_ref_2_const, u, x1,x2); + tgcr += new_thread (&U::virtual_const_ref_foo_2, u, x1,x2); + tgcr += new_thread (&U::virtual_const_ref_foo_2_const, u, x1,x2); + tgcr += new_thread (&U::virtual_const_ref_foo_const_ref_2, u, x1,x2); + tgcr += new_thread (&U::virtual_const_ref_foo_const_ref_2_const, u, x1,x2); + tgcr += new_thread (&U::virtual_const_ref_foo_ref_2, u, x1,x2); + tgcr += new_thread (&U::virtual_const_ref_foo_ref_2_const, u, x1,x2); + tg += new_thread (&U::foo_2, u, x1,x2); + tg += new_thread (&U::foo_2_const, u, x1,x2); + tg += new_thread (&U::foo_const_ref_2, u, x1,x2); + tg += new_thread (&U::foo_const_ref_2_const, u, x1,x2); + tg += new_thread (&U::foo_ref_2, u, x1,x2); + tg += new_thread (&U::foo_ref_2_const, u, x1,x2); + tgr += new_thread (&U::virtual_ref_foo_2, u, x1,x2); + tgr += new_thread (&U::virtual_ref_foo_2_const, u, x1,x2); + tgr += new_thread (&U::virtual_ref_foo_const_ref_2, u, x1,x2); + tgr += new_thread (&U::virtual_ref_foo_const_ref_2_const, u, x1,x2); + tgr += new_thread (&U::virtual_ref_foo_ref_2, u, x1,x2); + tgr += new_thread (&U::virtual_ref_foo_ref_2_const, u, x1,x2); + tg += new_thread (&U::virtual_foo_2, u, x1,x2); + tg += new_thread (&U::virtual_foo_2_const, u, x1,x2); + tg += new_thread (&U::virtual_foo_const_ref_2, u, x1,x2); + tg += new_thread (&U::virtual_foo_const_ref_2_const, u, x1,x2); + tg += new_thread (&U::virtual_foo_ref_2, u, x1,x2); + tg += new_thread (&U::virtual_foo_ref_2_const, u, x1,x2); + + tgr += spawn (&U::static_ref_foo_2) (x1,x2); + tgr += spawn (&U::static_ref_foo_const_ref_2) (x1,x2); + tgr += spawn (&U::static_ref_foo_ref_2) (x1,x2); + tgcr += spawn (&U::static_const_ref_foo_2) (x1,x2); + tgcr += spawn (&U::static_const_ref_foo_const_ref_2) (x1,x2); + tgcr += spawn (&U::static_const_ref_foo_ref_2) (x1,x2); + tg += spawn (&U::static_foo_2) (x1,x2); + tg += spawn (&U::static_foo_const_ref_2) (x1,x2); + tg += spawn (&U::static_foo_ref_2) (x1,x2); + tgr += new_thread (&U::ref_foo_3, u, x1,x2,x3); + tgr += new_thread (&U::ref_foo_3_const, u, x1,x2,x3); + tgr += new_thread (&U::ref_foo_const_ref_3, u, x1,x2,x3); + tgr += new_thread (&U::ref_foo_const_ref_3_const, u, x1,x2,x3); + tgr += new_thread (&U::ref_foo_ref_3, u, x1,x2,x3); + tgr += new_thread (&U::ref_foo_ref_3_const, u, x1,x2,x3); + tgcr += new_thread (&U::const_ref_foo_3, u, x1,x2,x3); + tgcr += new_thread (&U::const_ref_foo_3_const, u, x1,x2,x3); + tgcr += new_thread (&U::const_ref_foo_const_ref_3, u, x1,x2,x3); + tgcr += new_thread (&U::const_ref_foo_const_ref_3_const, u, x1,x2,x3); + tgcr += new_thread (&U::const_ref_foo_ref_3, u, x1,x2,x3); + tgcr += new_thread (&U::const_ref_foo_ref_3_const, u, x1,x2,x3); + tgcr += new_thread (&U::virtual_const_ref_foo_3, u, x1,x2,x3); + tgcr += new_thread (&U::virtual_const_ref_foo_3_const, u, x1,x2,x3); + tgcr += new_thread (&U::virtual_const_ref_foo_const_ref_3, u, x1,x2,x3); + tgcr += new_thread (&U::virtual_const_ref_foo_const_ref_3_const, u, x1,x2,x3); + tgcr += new_thread (&U::virtual_const_ref_foo_ref_3, u, x1,x2,x3); + tgcr += new_thread (&U::virtual_const_ref_foo_ref_3_const, u, x1,x2,x3); + tg += new_thread (&U::foo_3, u, x1,x2,x3); + tg += new_thread (&U::foo_3_const, u, x1,x2,x3); + tg += new_thread (&U::foo_const_ref_3, u, x1,x2,x3); + tg += new_thread (&U::foo_const_ref_3_const, u, x1,x2,x3); + tg += new_thread (&U::foo_ref_3, u, x1,x2,x3); + tg += new_thread (&U::foo_ref_3_const, u, x1,x2,x3); + tgr += new_thread (&U::virtual_ref_foo_3, u, x1,x2,x3); + tgr += new_thread (&U::virtual_ref_foo_3_const, u, x1,x2,x3); + tgr += new_thread (&U::virtual_ref_foo_const_ref_3, u, x1,x2,x3); + tgr += new_thread (&U::virtual_ref_foo_const_ref_3_const, u, x1,x2,x3); + tgr += new_thread (&U::virtual_ref_foo_ref_3, u, x1,x2,x3); + tgr += new_thread (&U::virtual_ref_foo_ref_3_const, u, x1,x2,x3); + tg += new_thread (&U::virtual_foo_3, u, x1,x2,x3); + tg += new_thread (&U::virtual_foo_3_const, u, x1,x2,x3); + tg += new_thread (&U::virtual_foo_const_ref_3, u, x1,x2,x3); + tg += new_thread (&U::virtual_foo_const_ref_3_const, u, x1,x2,x3); + tg += new_thread (&U::virtual_foo_ref_3, u, x1,x2,x3); + tg += new_thread (&U::virtual_foo_ref_3_const, u, x1,x2,x3); + + tgr += spawn (&U::static_ref_foo_3) (x1,x2,x3); + tgr += spawn (&U::static_ref_foo_const_ref_3) (x1,x2,x3); + tgr += spawn (&U::static_ref_foo_ref_3) (x1,x2,x3); + tgcr += spawn (&U::static_const_ref_foo_3) (x1,x2,x3); + tgcr += spawn (&U::static_const_ref_foo_const_ref_3) (x1,x2,x3); + tgcr += spawn (&U::static_const_ref_foo_ref_3) (x1,x2,x3); + tg += spawn (&U::static_foo_3) (x1,x2,x3); + tg += spawn (&U::static_foo_const_ref_3) (x1,x2,x3); + tg += spawn (&U::static_foo_ref_3) (x1,x2,x3); + tgr += new_thread (&U::ref_foo_4, u, x1,x2,x3,x4); + tgr += new_thread (&U::ref_foo_4_const, u, x1,x2,x3,x4); + tgr += new_thread (&U::ref_foo_const_ref_4, u, x1,x2,x3,x4); + tgr += new_thread (&U::ref_foo_const_ref_4_const, u, x1,x2,x3,x4); + tgr += new_thread (&U::ref_foo_ref_4, u, x1,x2,x3,x4); + tgr += new_thread (&U::ref_foo_ref_4_const, u, x1,x2,x3,x4); + tgcr += new_thread (&U::const_ref_foo_4, u, x1,x2,x3,x4); + tgcr += new_thread (&U::const_ref_foo_4_const, u, x1,x2,x3,x4); + tgcr += new_thread (&U::const_ref_foo_const_ref_4, u, x1,x2,x3,x4); + tgcr += new_thread (&U::const_ref_foo_const_ref_4_const, u, x1,x2,x3,x4); + tgcr += new_thread (&U::const_ref_foo_ref_4, u, x1,x2,x3,x4); + tgcr += new_thread (&U::const_ref_foo_ref_4_const, u, x1,x2,x3,x4); + tgcr += new_thread (&U::virtual_const_ref_foo_4, u, x1,x2,x3,x4); + tgcr += new_thread (&U::virtual_const_ref_foo_4_const, u, x1,x2,x3,x4); + tgcr += new_thread (&U::virtual_const_ref_foo_const_ref_4, u, x1,x2,x3,x4); + tgcr += new_thread (&U::virtual_const_ref_foo_const_ref_4_const, u, x1,x2,x3,x4); + tgcr += new_thread (&U::virtual_const_ref_foo_ref_4, u, x1,x2,x3,x4); + tgcr += new_thread (&U::virtual_const_ref_foo_ref_4_const, u, x1,x2,x3,x4); + tg += new_thread (&U::foo_4, u, x1,x2,x3,x4); + tg += new_thread (&U::foo_4_const, u, x1,x2,x3,x4); + tg += new_thread (&U::foo_const_ref_4, u, x1,x2,x3,x4); + tg += new_thread (&U::foo_const_ref_4_const, u, x1,x2,x3,x4); + tg += new_thread (&U::foo_ref_4, u, x1,x2,x3,x4); + tg += new_thread (&U::foo_ref_4_const, u, x1,x2,x3,x4); + tgr += new_thread (&U::virtual_ref_foo_4, u, x1,x2,x3,x4); + tgr += new_thread (&U::virtual_ref_foo_4_const, u, x1,x2,x3,x4); + tgr += new_thread (&U::virtual_ref_foo_const_ref_4, u, x1,x2,x3,x4); + tgr += new_thread (&U::virtual_ref_foo_const_ref_4_const, u, x1,x2,x3,x4); + tgr += new_thread (&U::virtual_ref_foo_ref_4, u, x1,x2,x3,x4); + tgr += new_thread (&U::virtual_ref_foo_ref_4_const, u, x1,x2,x3,x4); + tg += new_thread (&U::virtual_foo_4, u, x1,x2,x3,x4); + tg += new_thread (&U::virtual_foo_4_const, u, x1,x2,x3,x4); + tg += new_thread (&U::virtual_foo_const_ref_4, u, x1,x2,x3,x4); + tg += new_thread (&U::virtual_foo_const_ref_4_const, u, x1,x2,x3,x4); + tg += new_thread (&U::virtual_foo_ref_4, u, x1,x2,x3,x4); + tg += new_thread (&U::virtual_foo_ref_4_const, u, x1,x2,x3,x4); + + tgr += spawn (&U::static_ref_foo_4) (x1,x2,x3,x4); + tgr += spawn (&U::static_ref_foo_const_ref_4) (x1,x2,x3,x4); + tgr += spawn (&U::static_ref_foo_ref_4) (x1,x2,x3,x4); + tgcr += spawn (&U::static_const_ref_foo_4) (x1,x2,x3,x4); + tgcr += spawn (&U::static_const_ref_foo_const_ref_4) (x1,x2,x3,x4); + tgcr += spawn (&U::static_const_ref_foo_ref_4) (x1,x2,x3,x4); + tg += spawn (&U::static_foo_4) (x1,x2,x3,x4); + tg += spawn (&U::static_foo_const_ref_4) (x1,x2,x3,x4); + tg += spawn (&U::static_foo_ref_4) (x1,x2,x3,x4); + tgr += new_thread (&U::ref_foo_5, u, x1,x2,x3,x4,x5); + tgr += new_thread (&U::ref_foo_5_const, u, x1,x2,x3,x4,x5); + tgr += new_thread (&U::ref_foo_const_ref_5, u, x1,x2,x3,x4,x5); + tgr += new_thread (&U::ref_foo_const_ref_5_const, u, x1,x2,x3,x4,x5); + tgr += new_thread (&U::ref_foo_ref_5, u, x1,x2,x3,x4,x5); + tgr += new_thread (&U::ref_foo_ref_5_const, u, x1,x2,x3,x4,x5); + tgcr += new_thread (&U::const_ref_foo_5, u, x1,x2,x3,x4,x5); + tgcr += new_thread (&U::const_ref_foo_5_const, u, x1,x2,x3,x4,x5); + tgcr += new_thread (&U::const_ref_foo_const_ref_5, u, x1,x2,x3,x4,x5); + tgcr += new_thread (&U::const_ref_foo_const_ref_5_const, u, x1,x2,x3,x4,x5); + tgcr += new_thread (&U::const_ref_foo_ref_5, u, x1,x2,x3,x4,x5); + tgcr += new_thread (&U::const_ref_foo_ref_5_const, u, x1,x2,x3,x4,x5); + tgcr += new_thread (&U::virtual_const_ref_foo_5, u, x1,x2,x3,x4,x5); + tgcr += new_thread (&U::virtual_const_ref_foo_5_const, u, x1,x2,x3,x4,x5); + tgcr += new_thread (&U::virtual_const_ref_foo_const_ref_5, u, x1,x2,x3,x4,x5); + tgcr += new_thread (&U::virtual_const_ref_foo_const_ref_5_const, u, x1,x2,x3,x4,x5); + tgcr += new_thread (&U::virtual_const_ref_foo_ref_5, u, x1,x2,x3,x4,x5); + tgcr += new_thread (&U::virtual_const_ref_foo_ref_5_const, u, x1,x2,x3,x4,x5); + tg += new_thread (&U::foo_5, u, x1,x2,x3,x4,x5); + tg += new_thread (&U::foo_5_const, u, x1,x2,x3,x4,x5); + tg += new_thread (&U::foo_const_ref_5, u, x1,x2,x3,x4,x5); + tg += new_thread (&U::foo_const_ref_5_const, u, x1,x2,x3,x4,x5); + tg += new_thread (&U::foo_ref_5, u, x1,x2,x3,x4,x5); + tg += new_thread (&U::foo_ref_5_const, u, x1,x2,x3,x4,x5); + tgr += new_thread (&U::virtual_ref_foo_5, u, x1,x2,x3,x4,x5); + tgr += new_thread (&U::virtual_ref_foo_5_const, u, x1,x2,x3,x4,x5); + tgr += new_thread (&U::virtual_ref_foo_const_ref_5, u, x1,x2,x3,x4,x5); + tgr += new_thread (&U::virtual_ref_foo_const_ref_5_const, u, x1,x2,x3,x4,x5); + tgr += new_thread (&U::virtual_ref_foo_ref_5, u, x1,x2,x3,x4,x5); + tgr += new_thread (&U::virtual_ref_foo_ref_5_const, u, x1,x2,x3,x4,x5); + tg += new_thread (&U::virtual_foo_5, u, x1,x2,x3,x4,x5); + tg += new_thread (&U::virtual_foo_5_const, u, x1,x2,x3,x4,x5); + tg += new_thread (&U::virtual_foo_const_ref_5, u, x1,x2,x3,x4,x5); + tg += new_thread (&U::virtual_foo_const_ref_5_const, u, x1,x2,x3,x4,x5); + tg += new_thread (&U::virtual_foo_ref_5, u, x1,x2,x3,x4,x5); + tg += new_thread (&U::virtual_foo_ref_5_const, u, x1,x2,x3,x4,x5); + + tgr += spawn (&U::static_ref_foo_5) (x1,x2,x3,x4,x5); + tgr += spawn (&U::static_ref_foo_const_ref_5) (x1,x2,x3,x4,x5); + tgr += spawn (&U::static_ref_foo_ref_5) (x1,x2,x3,x4,x5); + tgcr += spawn (&U::static_const_ref_foo_5) (x1,x2,x3,x4,x5); + tgcr += spawn (&U::static_const_ref_foo_const_ref_5) (x1,x2,x3,x4,x5); + tgcr += spawn (&U::static_const_ref_foo_ref_5) (x1,x2,x3,x4,x5); + tg += spawn (&U::static_foo_5) (x1,x2,x3,x4,x5); + tg += spawn (&U::static_foo_const_ref_5) (x1,x2,x3,x4,x5); + tg += spawn (&U::static_foo_ref_5) (x1,x2,x3,x4,x5); + tgr += new_thread (&U::ref_foo_6, u, x1,x2,x3,x4,x5,x6); + tgr += new_thread (&U::ref_foo_6_const, u, x1,x2,x3,x4,x5,x6); + tgr += new_thread (&U::ref_foo_const_ref_6, u, x1,x2,x3,x4,x5,x6); + tgr += new_thread (&U::ref_foo_const_ref_6_const, u, x1,x2,x3,x4,x5,x6); + tgr += new_thread (&U::ref_foo_ref_6, u, x1,x2,x3,x4,x5,x6); + tgr += new_thread (&U::ref_foo_ref_6_const, u, x1,x2,x3,x4,x5,x6); + tgcr += new_thread (&U::const_ref_foo_6, u, x1,x2,x3,x4,x5,x6); + tgcr += new_thread (&U::const_ref_foo_6_const, u, x1,x2,x3,x4,x5,x6); + tgcr += new_thread (&U::const_ref_foo_const_ref_6, u, x1,x2,x3,x4,x5,x6); + tgcr += new_thread (&U::const_ref_foo_const_ref_6_const, u, x1,x2,x3,x4,x5,x6); + tgcr += new_thread (&U::const_ref_foo_ref_6, u, x1,x2,x3,x4,x5,x6); + tgcr += new_thread (&U::const_ref_foo_ref_6_const, u, x1,x2,x3,x4,x5,x6); + tgcr += new_thread (&U::virtual_const_ref_foo_6, u, x1,x2,x3,x4,x5,x6); + tgcr += new_thread (&U::virtual_const_ref_foo_6_const, u, x1,x2,x3,x4,x5,x6); + tgcr += new_thread (&U::virtual_const_ref_foo_const_ref_6, u, x1,x2,x3,x4,x5,x6); + tgcr += new_thread (&U::virtual_const_ref_foo_const_ref_6_const, u, x1,x2,x3,x4,x5,x6); + tgcr += new_thread (&U::virtual_const_ref_foo_ref_6, u, x1,x2,x3,x4,x5,x6); + tgcr += new_thread (&U::virtual_const_ref_foo_ref_6_const, u, x1,x2,x3,x4,x5,x6); + tg += new_thread (&U::foo_6, u, x1,x2,x3,x4,x5,x6); + tg += new_thread (&U::foo_6_const, u, x1,x2,x3,x4,x5,x6); + tg += new_thread (&U::foo_const_ref_6, u, x1,x2,x3,x4,x5,x6); + tg += new_thread (&U::foo_const_ref_6_const, u, x1,x2,x3,x4,x5,x6); + tg += new_thread (&U::foo_ref_6, u, x1,x2,x3,x4,x5,x6); + tg += new_thread (&U::foo_ref_6_const, u, x1,x2,x3,x4,x5,x6); + tgr += new_thread (&U::virtual_ref_foo_6, u, x1,x2,x3,x4,x5,x6); + tgr += new_thread (&U::virtual_ref_foo_6_const, u, x1,x2,x3,x4,x5,x6); + tgr += new_thread (&U::virtual_ref_foo_const_ref_6, u, x1,x2,x3,x4,x5,x6); + tgr += new_thread (&U::virtual_ref_foo_const_ref_6_const, u, x1,x2,x3,x4,x5,x6); + tgr += new_thread (&U::virtual_ref_foo_ref_6, u, x1,x2,x3,x4,x5,x6); + tgr += new_thread (&U::virtual_ref_foo_ref_6_const, u, x1,x2,x3,x4,x5,x6); + tg += new_thread (&U::virtual_foo_6, u, x1,x2,x3,x4,x5,x6); + tg += new_thread (&U::virtual_foo_6_const, u, x1,x2,x3,x4,x5,x6); + tg += new_thread (&U::virtual_foo_const_ref_6, u, x1,x2,x3,x4,x5,x6); + tg += new_thread (&U::virtual_foo_const_ref_6_const, u, x1,x2,x3,x4,x5,x6); + tg += new_thread (&U::virtual_foo_ref_6, u, x1,x2,x3,x4,x5,x6); + tg += new_thread (&U::virtual_foo_ref_6_const, u, x1,x2,x3,x4,x5,x6); + + tgr += spawn (&U::static_ref_foo_6) (x1,x2,x3,x4,x5,x6); + tgr += spawn (&U::static_ref_foo_const_ref_6) (x1,x2,x3,x4,x5,x6); + tgr += spawn (&U::static_ref_foo_ref_6) (x1,x2,x3,x4,x5,x6); + tgcr += spawn (&U::static_const_ref_foo_6) (x1,x2,x3,x4,x5,x6); + tgcr += spawn (&U::static_const_ref_foo_const_ref_6) (x1,x2,x3,x4,x5,x6); + tgcr += spawn (&U::static_const_ref_foo_ref_6) (x1,x2,x3,x4,x5,x6); + tg += spawn (&U::static_foo_6) (x1,x2,x3,x4,x5,x6); + tg += spawn (&U::static_foo_const_ref_6) (x1,x2,x3,x4,x5,x6); + tg += spawn (&U::static_foo_ref_6) (x1,x2,x3,x4,x5,x6); + tgr += new_thread (&U::ref_foo_7, u, x1,x2,x3,x4,x5,x6,x7); + tgr += new_thread (&U::ref_foo_7_const, u, x1,x2,x3,x4,x5,x6,x7); + tgr += new_thread (&U::ref_foo_const_ref_7, u, x1,x2,x3,x4,x5,x6,x7); + tgr += new_thread (&U::ref_foo_const_ref_7_const, u, x1,x2,x3,x4,x5,x6,x7); + tgr += new_thread (&U::ref_foo_ref_7, u, x1,x2,x3,x4,x5,x6,x7); + tgr += new_thread (&U::ref_foo_ref_7_const, u, x1,x2,x3,x4,x5,x6,x7); + tgcr += new_thread (&U::const_ref_foo_7, u, x1,x2,x3,x4,x5,x6,x7); + tgcr += new_thread (&U::const_ref_foo_7_const, u, x1,x2,x3,x4,x5,x6,x7); + tgcr += new_thread (&U::const_ref_foo_const_ref_7, u, x1,x2,x3,x4,x5,x6,x7); + tgcr += new_thread (&U::const_ref_foo_const_ref_7_const, u, x1,x2,x3,x4,x5,x6,x7); + tgcr += new_thread (&U::const_ref_foo_ref_7, u, x1,x2,x3,x4,x5,x6,x7); + tgcr += new_thread (&U::const_ref_foo_ref_7_const, u, x1,x2,x3,x4,x5,x6,x7); + tgcr += new_thread (&U::virtual_const_ref_foo_7, u, x1,x2,x3,x4,x5,x6,x7); + tgcr += new_thread (&U::virtual_const_ref_foo_7_const, u, x1,x2,x3,x4,x5,x6,x7); + tgcr += new_thread (&U::virtual_const_ref_foo_const_ref_7, u, x1,x2,x3,x4,x5,x6,x7); + tgcr += new_thread (&U::virtual_const_ref_foo_const_ref_7_const, u, x1,x2,x3,x4,x5,x6,x7); + tgcr += new_thread (&U::virtual_const_ref_foo_ref_7, u, x1,x2,x3,x4,x5,x6,x7); + tgcr += new_thread (&U::virtual_const_ref_foo_ref_7_const, u, x1,x2,x3,x4,x5,x6,x7); + tg += new_thread (&U::foo_7, u, x1,x2,x3,x4,x5,x6,x7); + tg += new_thread (&U::foo_7_const, u, x1,x2,x3,x4,x5,x6,x7); + tg += new_thread (&U::foo_const_ref_7, u, x1,x2,x3,x4,x5,x6,x7); + tg += new_thread (&U::foo_const_ref_7_const, u, x1,x2,x3,x4,x5,x6,x7); + tg += new_thread (&U::foo_ref_7, u, x1,x2,x3,x4,x5,x6,x7); + tg += new_thread (&U::foo_ref_7_const, u, x1,x2,x3,x4,x5,x6,x7); + tgr += new_thread (&U::virtual_ref_foo_7, u, x1,x2,x3,x4,x5,x6,x7); + tgr += new_thread (&U::virtual_ref_foo_7_const, u, x1,x2,x3,x4,x5,x6,x7); + tgr += new_thread (&U::virtual_ref_foo_const_ref_7, u, x1,x2,x3,x4,x5,x6,x7); + tgr += new_thread (&U::virtual_ref_foo_const_ref_7_const, u, x1,x2,x3,x4,x5,x6,x7); + tgr += new_thread (&U::virtual_ref_foo_ref_7, u, x1,x2,x3,x4,x5,x6,x7); + tgr += new_thread (&U::virtual_ref_foo_ref_7_const, u, x1,x2,x3,x4,x5,x6,x7); + tg += new_thread (&U::virtual_foo_7, u, x1,x2,x3,x4,x5,x6,x7); + tg += new_thread (&U::virtual_foo_7_const, u, x1,x2,x3,x4,x5,x6,x7); + tg += new_thread (&U::virtual_foo_const_ref_7, u, x1,x2,x3,x4,x5,x6,x7); + tg += new_thread (&U::virtual_foo_const_ref_7_const, u, x1,x2,x3,x4,x5,x6,x7); + tg += new_thread (&U::virtual_foo_ref_7, u, x1,x2,x3,x4,x5,x6,x7); + tg += new_thread (&U::virtual_foo_ref_7_const, u, x1,x2,x3,x4,x5,x6,x7); + + tgr += spawn (&U::static_ref_foo_7) (x1,x2,x3,x4,x5,x6,x7); + tgr += spawn (&U::static_ref_foo_const_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tgr += spawn (&U::static_ref_foo_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tgcr += spawn (&U::static_const_ref_foo_7) (x1,x2,x3,x4,x5,x6,x7); + tgcr += spawn (&U::static_const_ref_foo_const_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tgcr += spawn (&U::static_const_ref_foo_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tg += spawn (&U::static_foo_7) (x1,x2,x3,x4,x5,x6,x7); + tg += spawn (&U::static_foo_const_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tg += spawn (&U::static_foo_ref_7) (x1,x2,x3,x4,x5,x6,x7); + tgr += new_thread (&U::ref_foo_8, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgr += new_thread (&U::ref_foo_8_const, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgr += new_thread (&U::ref_foo_const_ref_8, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgr += new_thread (&U::ref_foo_const_ref_8_const, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgr += new_thread (&U::ref_foo_ref_8, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgr += new_thread (&U::ref_foo_ref_8_const, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += new_thread (&U::const_ref_foo_8, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += new_thread (&U::const_ref_foo_8_const, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += new_thread (&U::const_ref_foo_const_ref_8, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += new_thread (&U::const_ref_foo_const_ref_8_const, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += new_thread (&U::const_ref_foo_ref_8, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += new_thread (&U::const_ref_foo_ref_8_const, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += new_thread (&U::virtual_const_ref_foo_8, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += new_thread (&U::virtual_const_ref_foo_8_const, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += new_thread (&U::virtual_const_ref_foo_const_ref_8, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += new_thread (&U::virtual_const_ref_foo_const_ref_8_const, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += new_thread (&U::virtual_const_ref_foo_ref_8, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += new_thread (&U::virtual_const_ref_foo_ref_8_const, u, x1,x2,x3,x4,x5,x6,x7,x8); + tg += new_thread (&U::foo_8, u, x1,x2,x3,x4,x5,x6,x7,x8); + tg += new_thread (&U::foo_8_const, u, x1,x2,x3,x4,x5,x6,x7,x8); + tg += new_thread (&U::foo_const_ref_8, u, x1,x2,x3,x4,x5,x6,x7,x8); + tg += new_thread (&U::foo_const_ref_8_const, u, x1,x2,x3,x4,x5,x6,x7,x8); + tg += new_thread (&U::foo_ref_8, u, x1,x2,x3,x4,x5,x6,x7,x8); + tg += new_thread (&U::foo_ref_8_const, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgr += new_thread (&U::virtual_ref_foo_8, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgr += new_thread (&U::virtual_ref_foo_8_const, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgr += new_thread (&U::virtual_ref_foo_const_ref_8, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgr += new_thread (&U::virtual_ref_foo_const_ref_8_const, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgr += new_thread (&U::virtual_ref_foo_ref_8, u, x1,x2,x3,x4,x5,x6,x7,x8); + tgr += new_thread (&U::virtual_ref_foo_ref_8_const, u, x1,x2,x3,x4,x5,x6,x7,x8); + tg += new_thread (&U::virtual_foo_8, u, x1,x2,x3,x4,x5,x6,x7,x8); + tg += new_thread (&U::virtual_foo_8_const, u, x1,x2,x3,x4,x5,x6,x7,x8); + tg += new_thread (&U::virtual_foo_const_ref_8, u, x1,x2,x3,x4,x5,x6,x7,x8); + tg += new_thread (&U::virtual_foo_const_ref_8_const, u, x1,x2,x3,x4,x5,x6,x7,x8); + tg += new_thread (&U::virtual_foo_ref_8, u, x1,x2,x3,x4,x5,x6,x7,x8); + tg += new_thread (&U::virtual_foo_ref_8_const, u, x1,x2,x3,x4,x5,x6,x7,x8); + + tgr += spawn (&U::static_ref_foo_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgr += spawn (&U::static_ref_foo_const_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgr += spawn (&U::static_ref_foo_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += spawn (&U::static_const_ref_foo_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += spawn (&U::static_const_ref_foo_const_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tgcr += spawn (&U::static_const_ref_foo_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tg += spawn (&U::static_foo_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tg += spawn (&U::static_foo_const_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tg += spawn (&U::static_foo_ref_8) (x1,x2,x3,x4,x5,x6,x7,x8); + tg.join_all(); + tgr.join_all(); + tgcr.join_all(); +} diff --git a/tests/base/threads/threads_02.output b/tests/base/threads_02.output similarity index 100% rename from tests/base/threads/threads_02.output rename to tests/base/threads_02.output -- 2.39.5