From: bangerth <bangerth@0785d39b-7218-0410-832d-ea1e28bc413d>
Date: Thu, 19 Sep 2013 19:17:55 +0000 (+0000)
Subject: Make sure output gets sorted. Previously, we did this inside the Makefile, but this... 
X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=d66b082ea0f836857b390b19d9927e296acf1d21;p=dealii-svn.git

Make sure output gets sorted. Previously, we did this inside the Makefile, but this is no longer easily possible, so we do it in the program itself.

git-svn-id: https://svn.dealii.org/branches/branch_port_the_testsuite@30840 0785d39b-7218-0410-832d-ea1e28bc413d
---

diff --git a/tests/base/task_03.cc b/tests/base/task_03.cc
index 266aed58e4..95f50bad06 100644
--- a/tests/base/task_03.cc
+++ b/tests/base/task_03.cc
@@ -43,13 +43,19 @@ int main()
   deallog.depth_console(0);
   deallog.threshold_double(1.e-10);
 
-  Threads::Task<> t1 = Threads::new_task (test, 1);
   {
-    Threads::Task<> t2 = Threads::new_task (test, 2);
+    Threads::Task<> t1 = Threads::new_task (test, 1);
+    {
+      Threads::Task<> t2 = Threads::new_task (test, 2);
 
-    t1.join ();
-    t2.join ();
+      t1.join ();
+      t2.join ();
+    }
+
+    deallog << "OK" << std::endl;
   }
 
-  deallog << "OK" << std::endl;
+  deallog.detach ();
+  logfile.close ();
+  sort_file_contents ("output");
 }
diff --git a/tests/base/task_03.output b/tests/base/task_03.output
index 31275b0c8c..d239d4dd83 100644
--- a/tests/base/task_03.output
+++ b/tests/base/task_03.output
@@ -1,6 +1,6 @@
-
 DEAL::OK
 DEAL::Task 1 finished!
 DEAL::Task 1 starting...
 DEAL::Task 2 finished!
 DEAL::Task 2 starting...
+
diff --git a/tests/base/task_04.cc b/tests/base/task_04.cc
index e407e79415..f71d1efe24 100644
--- a/tests/base/task_04.cc
+++ b/tests/base/task_04.cc
@@ -59,4 +59,8 @@ int main()
   t2.join ();
 
   deallog << "OK" << std::endl;
+
+  deallog.detach ();
+  logfile.close ();
+  sort_file_contents ("output");
 }
diff --git a/tests/base/task_04.output b/tests/base/task_04.output
index b1638030c6..c48f9ab3c8 100644
--- a/tests/base/task_04.output
+++ b/tests/base/task_04.output
@@ -1,4 +1,3 @@
-
 DEAL::OK
 DEAL::Task 11 finished!
 DEAL::Task 11 starting...
@@ -12,3 +11,4 @@ DEAL::Task 22 finished!
 DEAL::Task 22 starting...
 DEAL::Task 2 finished!
 DEAL::Task 2 starting...
+
diff --git a/tests/base/task_06.cc b/tests/base/task_06.cc
index 46d5cbfca3..9a9092797c 100644
--- a/tests/base/task_06.cc
+++ b/tests/base/task_06.cc
@@ -47,11 +47,17 @@ int main()
   deallog.depth_console(0);
   deallog.threshold_double(1.e-10);
 
-  Threads::Thread<> t1 = Threads::new_thread (test, 1);
-  Threads::Thread<> t2 = Threads::new_thread (test, 2);
+  {
+    Threads::Thread<> t1 = Threads::new_thread (test, 1);
+    Threads::Thread<> t2 = Threads::new_thread (test, 2);
 
-  t1.join ();
-  t2.join ();
+    t1.join ();
+    t2.join ();
 
-  deallog << "OK" << std::endl;
+    deallog << "OK" << std::endl;
+  }
+
+  deallog.detach ();
+  logfile.close ();
+  sort_file_contents ("output");
 }
diff --git a/tests/base/task_06.output b/tests/base/task_06.output
index ea2b0acef0..364d378be0 100644
--- a/tests/base/task_06.output
+++ b/tests/base/task_06.output
@@ -1,4 +1,3 @@
-
 DEAL::OK
 DEAL::Task 11 finished!
 DEAL::Task 11 starting...
@@ -8,3 +7,4 @@ DEAL::Task 1 finished!
 DEAL::Task 1 starting...
 DEAL::Task 2 finished!
 DEAL::Task 2 starting...
+
diff --git a/tests/base/task_07.cc b/tests/base/task_07.cc
index 77c1ffee13..367d4f1feb 100644
--- a/tests/base/task_07.cc
+++ b/tests/base/task_07.cc
@@ -49,4 +49,8 @@ int main()
   tg.join_all ();
 
   deallog << "OK" << std::endl;
+
+  deallog.detach ();
+  logfile.close ();
+  sort_file_contents ("output");
 }
diff --git a/tests/base/task_07.output b/tests/base/task_07.output
index 31275b0c8c..d239d4dd83 100644
--- a/tests/base/task_07.output
+++ b/tests/base/task_07.output
@@ -1,6 +1,6 @@
-
 DEAL::OK
 DEAL::Task 1 finished!
 DEAL::Task 1 starting...
 DEAL::Task 2 finished!
 DEAL::Task 2 starting...
+
diff --git a/tests/base/task_08.cc b/tests/base/task_08.cc
index 09299f8d07..d101a8fbe6 100644
--- a/tests/base/task_08.cc
+++ b/tests/base/task_08.cc
@@ -43,7 +43,13 @@ int main()
   deallog.depth_console(0);
   deallog.threshold_double(1.e-10);
 
-  Threads::new_task (test, 1);
+  {
+    Threads::new_task (test, 1);
 
-  deallog << "OK" << std::endl;
+    deallog << "OK" << std::endl;
+  }
+
+  deallog.detach ();
+  logfile.close ();
+  sort_file_contents ("output");
 }
diff --git a/tests/base/task_08.output b/tests/base/task_08.output
index ce2a33d550..16ffb5991b 100644
--- a/tests/base/task_08.output
+++ b/tests/base/task_08.output
@@ -1,3 +1,3 @@
-
 DEAL::OK
 DEAL::Task 1 finished!
+
diff --git a/tests/base/thread_validity_07.cc b/tests/base/thread_validity_07.cc
index 61e218368c..fec5f68578 100644
--- a/tests/base/thread_validity_07.cc
+++ b/tests/base/thread_validity_07.cc
@@ -61,4 +61,8 @@ int main()
 
   waiter_threads.join_all ();
   deallog << "All waiting threads finished." << std::endl;
+
+  deallog.detach ();
+  logfile.close ();
+  sort_file_contents ("output");
 }
diff --git a/tests/base/threads_01.cc b/tests/base/threads_01.cc
index 3045c84a75..9f7e5eee7b 100644
--- a/tests/base/threads_01.cc
+++ b/tests/base/threads_01.cc
@@ -22,1623 +22,1623 @@
 template <int> struct X {};
 struct U {
   virtual ~U () {}
-  X<0> foo_0 () { 
+  X<0> foo_0 () {
     deallog << __PRETTY_FUNCTION__ << std::endl;
     static X<0> x; return x;
   }
-  static X<0> static_foo_0 () { 
+  static X<0> static_foo_0 () {
     deallog << __PRETTY_FUNCTION__ << std::endl;
     static X<0> x; return x;
   }
-  X<0> & ref_foo_0 () { 
+  X<0> & ref_foo_0 () {
     deallog << __PRETTY_FUNCTION__ << std::endl;
     static X<0> x; return x;
   }
-  static X<0> & static_ref_foo_0 () { 
+  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 () { 
+  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 () { 
+  X<0> foo_ref_0 () {
     deallog << __PRETTY_FUNCTION__ << std::endl;
     static X<0> x; return x;
   }
-  static X<0> static_foo_ref_0 () { 
+  static X<0> static_foo_ref_0 () {
     deallog << __PRETTY_FUNCTION__ << std::endl;
     static X<0> x; return x;
   }
-  X<0> & ref_foo_ref_0 () { 
+  X<0> & ref_foo_ref_0 () {
     deallog << __PRETTY_FUNCTION__ << std::endl;
     static X<0> x; return x;
   }
-  const X<0> & const_ref_foo_0 () { 
+  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 () { 
+  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 () { 
+  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 { 
+  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 { 
+  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 { 
+  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 () { 
+  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 () { 
+  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 () { 
+  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 { 
+  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 { 
+  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 { 
+  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 () { 
+  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 () { 
+  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 () { 
+  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 () { 
+  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 () { 
+  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 () { 
+  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 () { 
+  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 { 
+  X<0> foo_0_const () const {
     deallog << __PRETTY_FUNCTION__ << std::endl;
     static X<0> x; return x;
   }
-  X<0> & ref_foo_0_const () const { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 () { 
+  virtual X<0> virtual_foo_0 () {
     deallog << __PRETTY_FUNCTION__ << std::endl;
     static X<0> x; return x;
   }
-  virtual X<0> & virtual_ref_foo_0 () { 
+  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 () { 
+  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 () { 
+  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 () { 
+  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 () { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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;
   }
@@ -2077,4 +2077,8 @@ X<8> x8;
   tg.join_all();
   tgr.join_all();
   tgcr.join_all();
+
+  deallog.detach ();
+  logfile.close ();
+  sort_file_contents ("output");
 }
diff --git a/tests/base/threads_01.output b/tests/base/threads_01.output
index 607c1f60f2..7d0c10a3ca 100644
--- a/tests/base/threads_01.output
+++ b/tests/base/threads_01.output
@@ -1,4 +1,3 @@
-
 DEAL::const X<0>& U::const_ref_foo_0()
 DEAL::const X<0>& U::const_ref_foo_0_const() const
 DEAL::const X<0>& U::const_ref_foo_1_const(X<1>) const
@@ -404,3 +403,4 @@ DEAL::X<0>& U::ref_foo_ref_7_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7
 DEAL::X<0>& U::ref_foo_ref_7(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&)
 DEAL::X<0>& U::ref_foo_ref_8_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&, X<8>&) const
 DEAL::X<0>& U::ref_foo_ref_8(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&, X<8>&)
+
diff --git a/tests/base/threads_02.cc b/tests/base/threads_02.cc
index 7d1496c27f..81cbe489e7 100644
--- a/tests/base/threads_02.cc
+++ b/tests/base/threads_02.cc
@@ -22,1623 +22,1623 @@
 template <int> struct X {};
 struct U {
   virtual ~U () {}
-  X<0> foo_0 () { 
+  X<0> foo_0 () {
     deallog << __PRETTY_FUNCTION__ << std::endl;
     static X<0> x; return x;
   }
-  static X<0> static_foo_0 () { 
+  static X<0> static_foo_0 () {
     deallog << __PRETTY_FUNCTION__ << std::endl;
     static X<0> x; return x;
   }
-  X<0> & ref_foo_0 () { 
+  X<0> & ref_foo_0 () {
     deallog << __PRETTY_FUNCTION__ << std::endl;
     static X<0> x; return x;
   }
-  static X<0> & static_ref_foo_0 () { 
+  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 () { 
+  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 () { 
+  X<0> foo_ref_0 () {
     deallog << __PRETTY_FUNCTION__ << std::endl;
     static X<0> x; return x;
   }
-  static X<0> static_foo_ref_0 () { 
+  static X<0> static_foo_ref_0 () {
     deallog << __PRETTY_FUNCTION__ << std::endl;
     static X<0> x; return x;
   }
-  X<0> & ref_foo_ref_0 () { 
+  X<0> & ref_foo_ref_0 () {
     deallog << __PRETTY_FUNCTION__ << std::endl;
     static X<0> x; return x;
   }
-  const X<0> & const_ref_foo_0 () { 
+  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 () { 
+  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 () { 
+  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 { 
+  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 { 
+  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 { 
+  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 () { 
+  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 () { 
+  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 () { 
+  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 { 
+  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 { 
+  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 { 
+  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 () { 
+  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 () { 
+  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 () { 
+  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 () { 
+  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 () { 
+  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 () { 
+  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 () { 
+  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 { 
+  X<0> foo_0_const () const {
     deallog << __PRETTY_FUNCTION__ << std::endl;
     static X<0> x; return x;
   }
-  X<0> & ref_foo_0_const () const { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 () { 
+  virtual X<0> virtual_foo_0 () {
     deallog << __PRETTY_FUNCTION__ << std::endl;
     static X<0> x; return x;
   }
-  virtual X<0> & virtual_ref_foo_0 () { 
+  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 () { 
+  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 () { 
+  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 () { 
+  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 () { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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 { 
+  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>) { 
+  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>) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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>&) { 
+  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;
   }
@@ -2077,4 +2077,8 @@ X<8> x8;
   tg.join_all();
   tgr.join_all();
   tgcr.join_all();
+
+  deallog.detach ();
+  logfile.close ();
+  sort_file_contents ("output");
 }
diff --git a/tests/base/threads_02.output b/tests/base/threads_02.output
index 607c1f60f2..7d0c10a3ca 100644
--- a/tests/base/threads_02.output
+++ b/tests/base/threads_02.output
@@ -1,4 +1,3 @@
-
 DEAL::const X<0>& U::const_ref_foo_0()
 DEAL::const X<0>& U::const_ref_foo_0_const() const
 DEAL::const X<0>& U::const_ref_foo_1_const(X<1>) const
@@ -404,3 +403,4 @@ DEAL::X<0>& U::ref_foo_ref_7_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7
 DEAL::X<0>& U::ref_foo_ref_7(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&)
 DEAL::X<0>& U::ref_foo_ref_8_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&, X<8>&) const
 DEAL::X<0>& U::ref_foo_ref_8(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&, X<8>&)
+
diff --git a/tests/tests.h b/tests/tests.h
index d31e36136f..15b1f49adf 100644
--- a/tests/tests.h
+++ b/tests/tests.h
@@ -196,6 +196,20 @@ struct MPILogInitAll
 
 
 
+/*
+ * Some tests (notably base/thread*, base/task*) create output that
+ * comes out in random order. To make the output of these tests comparable,
+ * we need to sort them.
+ *
+ * This function does just that with the file given. All streams writing
+ * to this should be closed when calling this function.
+ */
+void sort_file_contents (const std::string &filename)
+{
+  std::system ((std::string ("sort ") + filename + " -o " + filename).c_str());
+}
+
+