Make sure output gets sorted. Previously, we did this inside the Makefile, but this...

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 266aed58e41761b3f1b3b8c139e980bc10288190..95f50bad06da164a6c560aab16e5f2905ebe1f24 100644 (file)
--- 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 31275b0c8c9591e104b29e531afceef13db4a7f4..d239d4dd83034015f2b1433e2a3ee79cef0a3e9a 100644 (file)
--- 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 e407e794155cf14ff25775b015431c8b4798a569..f71d1efe2482ce99e411b6ba648b8454d52b8f23 100644 (file)
--- 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 b1638030c63201492739cec5fc2f8e36ec8986cc..c48f9ab3c88159fa41af93e66dc194eee1ada277 100644 (file)
--- 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 46d5cbfca3b673ed074e30cd2800bd920ccb3e64..9a9092797c2b4f5c0a68a6095c9a09d39f3c0dfe 100644 (file)
--- 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 ea2b0acef0a2d517578cd3c28d3be61bfa94b629..364d378be0acf4c552e3eb333f1b30ec80c5c07c 100644 (file)
--- 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 77c1ffee13010dc96a4d32f938bbb2551cb3bc12..367d4f1febd5cbf22be69e9cc9ee974c99b5c199 100644 (file)
--- 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 31275b0c8c9591e104b29e531afceef13db4a7f4..d239d4dd83034015f2b1433e2a3ee79cef0a3e9a 100644 (file)
--- 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 09299f8d07438bf2c11cda441e6a4d1a41f8590e..d101a8fbe6ea37b4e3bc4a479a9921600b178c6a 100644 (file)
--- 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 ce2a33d5500ad0498deda974e03a1bc33fb4da7a..16ffb5991beb9294197433c9e98878cebc687e05 100644 (file)
--- 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 61e218368c22b17bb291f6d5ce4e403bfbbd8944..fec5f68578c26255787c2e4a236d7c1e032aa979 100644 (file)
--- 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 3045c84a750e37971e11b99f9abb734251796b43..9f7e5eee7b8c9532ac0bf60aa287f8ca3ed4620d 100644 (file)
--- 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 607c1f60f2a08e9140b8509e6bcc8de9aa215e82..7d0c10a3caf07492ad82a5ec26c2a5d47e666303 100644 (file)
--- 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 7d1496c27fae99fdf2f2e4db64e74353d4d21f86..81cbe489e740fcfce33bc0febb392dcbac12a0fb 100644 (file)
--- 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 607c1f60f2a08e9140b8509e6bcc8de9aa215e82..7d0c10a3caf07492ad82a5ec26c2a5d47e666303 100644 (file)
--- 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 d31e36136f53eac2f7fc7384a6d6142903cb3d13..15b1f49adff414d7ed81fe342d1bf585c38119f0 100644 (file)
--- 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());
+}
+
+