]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Reintroduce threads_0? tests
authorMatthias Maier <tamiko@kyomu.43-1.org>
Tue, 20 Aug 2013 18:21:48 +0000 (18:21 +0000)
committerMatthias Maier <tamiko@kyomu.43-1.org>
Tue, 20 Aug 2013 18:21:48 +0000 (18:21 +0000)
git-svn-id: https://svn.dealii.org/branches/branch_port_the_testsuite@30360 0785d39b-7218-0410-832d-ea1e28bc413d

tests/base/Makefile [deleted file]
tests/base/threads/threads.pl [deleted file]
tests/base/threads_01.cc [new file with mode: 0644]
tests/base/threads_01.output [moved from tests/base/threads/threads_01.output with 100% similarity]
tests/base/threads_02.cc [new file with mode: 0644]
tests/base/threads_02.output [moved from tests/base/threads/threads_02.output with 100% similarity]

diff --git a/tests/base/Makefile b/tests/base/Makefile
deleted file mode 100644 (file)
index 1f4f76a..0000000
+++ /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 (file)
index 9289d75..0000000
+++ /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<N> 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 <base/thread_management.h>\n";
-print "#include <base/logstream.h>\n";
-print "#include <fstream>\n";
-print "#include <iostream>\n";
-print "template <int> 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<X<0> > tg;\n";
-print "  ThreadGroup<X<0>&> tgr;\n";
-print "  ThreadGroup<const X<0>&> 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 (file)
index 0000000..3045c84
--- /dev/null
@@ -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 <base/thread_management.h>
+#include <base/logstream.h>
+#include <fstream>
+#include <iostream>
+template <int> 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<X<0> > tg;
+  ThreadGroup<X<0>&> tgr;
+  ThreadGroup<const X<0>&> 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_02.cc b/tests/base/threads_02.cc
new file mode 100644 (file)
index 0000000..7d1496c
--- /dev/null
@@ -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 <base/thread_management.h>
+#include <base/logstream.h>
+#include <fstream>
+#include <iostream>
+template <int> 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<X<0> > tg;
+  ThreadGroup<X<0>&> tgr;
+  ThreadGroup<const X<0>&> 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();
+}

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.