Remove deprecated Threads functionalities

diff --git a/doc/news/changes/incompatibilities/20230630DanielArndt-3 b/doc/news/changes/incompatibilities/20230630DanielArndt-3
new file mode 100644 (file)
index 0000000..5fc2433
--- /dev/null
+++ b/doc/news/changes/incompatibilities/20230630DanielArndt-3
@@ -0,0 +1,5 @@
+Removed: The deprecated classes Threads::Thread,
+and Threads::ThreadGroup and the function
+Threads::new_thread() has been removed.
+<br>
+(Daniel Arndt, 2023/07/01)

diff --git a/include/deal.II/base/thread_management.h b/include/deal.II/base/thread_management.h
index b41dc020964f355c035711fe22c9e950b100e7a4..ef83e24438334075eae017610033222368687c7a 100644 (file)
--- a/include/deal.II/base/thread_management.h
+++ b/include/deal.II/base/thread_management.h
@@ -351,328 +351,6 @@ namespace Threads
 
 
 
-  namespace internal
-  {
-    template <typename RT>
-    inline void
-    call(const std::function<RT()> & function,
-         internal::return_value<RT> &ret_val)
-    {
-      ret_val.set(function());
-    }
-
-
-    inline void
-    call(const std::function<void()> &function, internal::return_value<void> &)
-    {
-      function();
-    }
-  } // namespace internal
-
-
-
-  namespace internal
-  {
-    /**
-     * A class that represents threads. For each thread, we create exactly one
-     * of these objects -- exactly one because it carries the returned value
-     * of the function called on the thread.
-     *
-     * While we have only one of these objects per thread, several
-     * Threads::Thread objects may refer to this descriptor. If all Thread
-     * objects go out of scope the ThreadDescriptor will detach from the
-     * thread before being destroyed.
-     */
-    template <typename RT>
-    struct ThreadDescriptor
-    {
-      /**
-       * An object that represents the thread started.
-       */
-      std::thread thread;
-
-      /**
-       * An object that will hold the value returned by the function called on
-       * the thread.
-       *
-       * The return value is stored in a shared_ptr because we might abandon
-       * the ThreadDescriptor.  This makes sure the object stays alive
-       * until the thread exits.
-       */
-      std::shared_ptr<return_value<RT>> ret_val;
-
-      /**
-       * An atomic  bool variable that is initially false, is set to true
-       * when a new thread is started, and is set back to false once join()
-       * has been called.
-       *
-       * We use this variable to make sure we can call join() twice on the
-       * same thread. For some reason, the C++ standard library throws a
-       * std::system_error exception if one tries to call std::thread::join
-       * twice (and in fact, before the second call, std::thread::joinable
-       * returns false) but this is a somewhat desirable thing to do because
-       * one doesn't have to keep track whether join() has been called before.
-       * Using this variable, whenever we have called join() before, the
-       * variable is set to true and we can skip over calling
-       * std::thread::join() a second time. Access to this variable is guarded
-       * by the following mutex.
-       *
-       * @note Historically, we did not need the mutex for this variable:
-       * threads can only be joined from the thread that created it
-       * originally. Consequently, everything that happens in a function that
-       * does not create threads (such as the join() function below) looks
-       * atomic to the outside world. Since we clear and test thread_is_active
-       * in the same function as we call std::thread::join, these actions are
-       * atomic and need no mutex. Of course, two threads may call join() on
-       * the same thread object at the same time, but this action is undefined
-       * anyway since they can not both join the same thread. That said, more
-       * recent C++ standards do not appear to have the requirement any more
-       * that the only thread that can call join() is the one that created the
-       * thread. Neither does `pthread_join` appear to have this requirement any
-       * more.  Consequently, we can in fact join from different threads and
-       * we test this in base/thread_validity_07.
-       *
-       * @note The reason why we need to use a std::atomic<bool> is
-       * discussed in detail in the documentation of
-       * Task::task_has_finished.
-       */
-      std::atomic<bool> thread_is_active;
-
-      /**
-       * Mutex guarding access to the previous variable.
-       */
-      Mutex thread_is_active_mutex;
-
-      /**
-       * Default constructor.
-       */
-      ThreadDescriptor()
-        : thread_is_active(false)
-      {}
-
-      ~ThreadDescriptor()
-      {
-        if (!thread_is_active)
-          return;
-        thread.detach();
-        thread_is_active = false;
-      }
-
-      /**
-       * Start the thread and let it put its return value into the ret_val
-       * object.
-       */
-      void
-      start(const std::function<RT()> &function)
-      {
-        thread_is_active = true;
-        ret_val          = std::make_shared<return_value<RT>>();
-        thread           = std::thread(thread_entry_point, function, ret_val);
-      }
-
-
-      /**
-       * Wait for the thread to end.
-       */
-      void
-      join()
-      {
-        // see if the thread hasn't been joined yet. if it has, then
-        // join() is a no-op. use schmidt's double-checking strategy
-        // to use the mutex only when necessary
-        if (thread_is_active == false)
-          return;
-
-        std::lock_guard<std::mutex> lock(thread_is_active_mutex);
-        if (thread_is_active == true)
-          {
-            Assert(thread.joinable(), ExcInternalError());
-            thread.join();
-            thread_is_active = false;
-          }
-      }
-
-    private:
-      /**
-       * The function that runs on the thread.
-       */
-      static void
-      thread_entry_point(const std::function<RT()> &       function,
-                         std::shared_ptr<return_value<RT>> ret_val)
-      {
-        // call the function in question. since an exception that is
-        // thrown from one of the called functions will not propagate
-        // to the main thread, it will kill the program if not treated
-        // here before we return to the operating system's thread
-        // library
-        try
-          {
-            call(function, *ret_val);
-          }
-        catch (const std::exception &exc)
-          {
-            internal::handle_std_exception(exc);
-          }
-        catch (...)
-          {
-            internal::handle_unknown_exception();
-          }
-      }
-    };
-  } // namespace internal
-
-
-  /**
-   * An object that represents a spawned thread. This object can be freely
-   * copied around in user space, and all instances will represent the same
-   * thread and can require to wait for its termination and access its return
-   * value.
-   *
-   * Threads can be abandoned, i.e. if you just call Threads::new_thread but
-   * don't care about the returned object, or if you assign the return
-   * Threads::Thread object to an object that subsequently goes out of scope,
-   * then the thread previously created will still continue to do work. You
-   * will simply not be able to access its return value any more, and it may
-   * also happen that your program terminates before the thread has finished
-   * its work.
-   *
-   * The default value of the template argument is <code>void</code>, so if
-   * the function you are calling on a new thread has no return value, you can
-   * omit the template argument.
-   *
-   * @ingroup threads
-   *
-   * @deprecated Use std::thread or std::jthread instead.
-   *
-   * @note Since this class is used in ThreadGroup, its constructors, rather
-   * than the class itself, are deprecated to allow compilation with
-   * -Werror=deprecated-declarations.
-   */
-  template <typename RT = void>
-  class Thread
-  {
-  public:
-    /**
-     * Construct a thread object with a function object.
-     */
-    DEAL_II_DEPRECATED
-    Thread(const std::function<RT()> &function)
-      : thread_descriptor(new internal::ThreadDescriptor<RT>())
-    {
-      // in a second step, start the thread.
-      thread_descriptor->start(function);
-    }
-
-    /**
-     * Default constructor. You can't do much with a thread object constructed
-     * this way, except for assigning it a thread object that holds data
-     * created by the new_thread() functions.
-     */
-    DEAL_II_DEPRECATED
-    Thread() = default;
-
-    /**
-     * Copy constructor.
-     */
-    DEAL_II_DEPRECATED
-    Thread(const Thread<RT> &t)
-      : thread_descriptor(t.thread_descriptor)
-    {}
-
-    /**
-     * Join the thread represented by this object, i.e. wait for it to finish.
-     * If you have used the default constructor of this class and have not
-     * assigned a thread object to it, then this function is a no-op.
-     */
-    void
-    join() const
-    {
-      if (thread_descriptor)
-        thread_descriptor->join();
-    }
-
-    /**
-     * Get the return value of the function of the thread. Since it
-     * is only available once the thread finishes, this function
-     * internally also calls join(). You can call this function
-     * multiple times as long as the object refers to the same task,
-     * and expect to get the same return value every time. (With the
-     * exception of the case where the returned object has been moved;
-     * see below.)
-     *
-     * @note The function returns a <i>non-@p const reference</i> to
-     * the returned object, instead of the returned object. This
-     * allows writing code such as
-     * @code
-     *   Threads::Thread<int> t = Threads::new_thread (
-     *     ...function returning an int...);
-     *   t.return_value() = 42;      // overwrite returned value
-     *   int i = t.return_value();   // i is now 42
-     * @endcode
-     * You will rarely have a need to write such code. On the other hand,
-     * the function needs to return a writable (non-@p const) reference to
-     * support code such as this:
-     * @code
-     *   std::unique_ptr<int> create_int (const std::string &s)
-     *   {
-     *     ...
-     *   }
-     *
-     *   void f()
-     *   {
-     *     Threads::Thread<std::unique_ptr<int>>
-     *       t = Threads::new_thread (&create_int, "42");
-     *
-     *     std::unique_ptr<int> i = std::move(t.return_value());
-     *     ...
-     *   }
-     * @endcode
-     * Here, it is necessary to `std::move` the returned object (namely,
-     * the <code>std::unique_ptr</code> object) because
-     * <code>std::unique_ptr</code> objects can not be copied. In other words,
-     * to get the pointer out of the object returned from the thread, it needs
-     * to be moved, and in order to be moved, the current function needs to
-     * return a writable (non-@p const) reference.
-     */
-    typename internal::return_value<RT>::reference_type
-    return_value()
-    {
-      join();
-      return thread_descriptor->ret_val->get();
-    }
-
-    /**
-     * Return true if this object has had a thread associated with it, either
-     * by using the non-default constructor or by assignment.
-     */
-    bool
-    valid() const
-    {
-      return static_cast<bool>(thread_descriptor);
-    }
-
-
-    /**
-     * Check for equality of thread objects. Since objects of this class store
-     * an implicit pointer to an object that exists exactly once for each
-     * thread, the check is simply to compare these pointers.
-     */
-    bool
-    operator==(const Thread &t) const
-    {
-      return thread_descriptor == t.thread_descriptor;
-    }
-
-  private:
-    /**
-     * Shared pointer to the object representing the thread, and abstracting
-     * operating system functions to work on it. This also makes sure that the
-     * object lives as long as there is at least one subscriber to it.
-     */
-    std::shared_ptr<internal::ThreadDescriptor<RT>> thread_descriptor;
-  };
-
-
   namespace internal
   {
     /**
@@ -710,228 +388,9 @@ namespace Threads
         return std::ref(t);
       }
     };
-  } // namespace internal
-
-
-
-  // ----------- thread starters for functions not taking any parameters
-
-  /**
-   * Overload of the new_thread function for objects that can be converted to
-   * std::function<RT ()>, i.e. anything that can be called like a
-   * function object without arguments and returning an object of type RT (or
-   * void).
-   *
-   * @deprecated Use std::thread or std::jthread instead.
-   *
-   * @ingroup threads
-   */
-  template <typename RT>
-  DEAL_II_DEPRECATED inline Thread<RT>
-  new_thread(const std::function<RT()> &function)
-  {
-    // Here and below we need to disable deprecation warnings for calling the
-    // constructor in this function - as this function itself is deprecated
-    // these warnings are not helpful. This problem only appears in some
-    // configurations (e.g., Debian 11 with GCC-10).
-    DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
-    return Thread<RT>(function);
-    DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
-  }
 
 
 
-  /**
-   * Overload of the new_thread() function for objects that can be called like a
-   * function object without arguments. In particular, this function allows
-   * calling Threads::new_thread() with either objects that result from using
-   * std::bind, or using lambda functions. For example, this function is called
-   * when writing code such as
-   * @code
-   * Threads::Thread<int>
-   *   thread = Threads::new_thread ( [] () {
-   *                                          do_this();
-   *                                          then_do_that();
-   *                                          return 42;
-   *                                        });
-   * @endcode
-   * Here, we run the sequence of functions
-   * <code>do_this()</code> and <code>then_do_that()</code> on
-   * a separate thread, by making the lambda function declared here the
-   * function to execute on the thread. The lambda function then returns
-   * 42 (which is a bit pointless here, but it could of course be some
-   * computed number), and this is going to be the returned value you
-   * can later retrieve via <code>thread.return_value()</code> once the
-   * thread (i.e., the body of the lambda function) has completed.
-   *
-   * @note Every lambda function (or whatever else it is you pass to
-   *   the new_thread() function here, for example the result of a
-   *   std::bind() expression) has a return type and consequently
-   *   returns an object of this type. This type can be inferred
-   *   using the C++11 <code>decltype</code> statement used in the
-   *   declaration of this function, and it is then used as the template
-   *   argument of the Threads::Thread object returned by the current function.
-   *   In the example above, because the lambda function returns 42
-   *   (which in C++ has data type <code>int</code>), the inferred
-   *   type is <code>int</code> and the task object will have type
-   *   <code>Task@<int@></code>. In other words, it is not <i>necessary</i>
-   *   to explicitly specify in user code what that return type
-   *   of the lambda or std::bind expression will be, though it is
-   *   possible to explicitly do so by (entirely equivalently) writing
-   *   @code
-   *   Threads::Thread<int>
-   *     thread = Threads::new_thread ( [] () -> int {
-   *                                                   do_this();
-   *                                                   then_do_that();
-   *                                                   return 42;
-   *                                                 });
-   *   @endcode
-   *
-   * @note In practice, the lambda functions you will pass to
-   *   new_thread() will of course typically be more complicated.
-   *   In particular, they will likely <i>capture</i> variables
-   *   from the surrounding context and use them within the lambda.
-   *   See
-   * https://en.wikipedia.org/wiki/Anonymous_function#C.2B.2B_.28since_C.2B.2B11.29
-   *   for more on how lambda functions work.
-   *
-   * @note If you pass a lambda function as an argument to the
-   *   current function that captures a variable <i>by reference</i>,
-   *   or if you use a std::bind that binds a function argument to
-   *   a reference variable using std::ref() or std::cref(), then
-   *   obviously you can only do this if the variables you reference
-   *   or capture have a lifetime that extends at least until the time
-   *   where the thread finishes.
-   *
-   * @deprecated Use std::thread or std::jthread instead.
-   *
-   * @ingroup CPP11
-   *
-   * @dealiiConceptRequires{(std::invocable<FunctionObjectType>)}
-   */
-  template <typename FunctionObjectType>
-  DEAL_II_CXX20_REQUIRES((std::invocable<FunctionObjectType>))
-  DEAL_II_DEPRECATED inline auto new_thread(FunctionObjectType function_object)
-    -> Thread<decltype(function_object())>
-  {
-    // See the comment in the first new_thread() implementation
-    DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
-    using return_type = decltype(function_object());
-    return Thread<return_type>(std::function<return_type()>(function_object));
-    DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
-  }
-
-
-
-  /**
-   * Overload of the new_thread function for non-member or static member
-   * functions.
-   *
-   * @deprecated Use std::thread or std::jthread instead.
-   *
-   * @ingroup threads
-   */
-  template <typename RT, typename... Args>
-  DEAL_II_DEPRECATED inline Thread<RT>
-  new_thread(RT (*fun_ptr)(Args...), std_cxx20::type_identity_t<Args>... args)
-  {
-    // See the comment in the first new_thread() implementation
-    DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
-    auto dummy = std::make_tuple(internal::maybe_make_ref<Args>::act(args)...);
-    return new_thread(
-      [dummy, fun_ptr]() -> RT { return std_cxx17::apply(fun_ptr, dummy); });
-    DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
-  }
-
-
-
-  /**
-   * Overload of the non-const new_thread function for member functions.
-   *
-   * @deprecated Use std::thread or std::jthread instead.
-   *
-   * @ingroup threads
-   */
-  template <typename RT, typename C, typename... Args>
-  DEAL_II_DEPRECATED inline Thread<RT>
-  new_thread(RT (C::*fun_ptr)(Args...),
-             std_cxx20::type_identity_t<C> &c,
-             std_cxx20::type_identity_t<Args>... args)
-  {
-    // NOLINTNEXTLINE(modernize-avoid-bind) silence clang-tidy
-    return new_thread(std::function<RT()>(std::bind(
-      fun_ptr, std::ref(c), internal::maybe_make_ref<Args>::act(args)...)));
-  }
-
-  /**
-   * Overload of the new_thread function for const member functions.
-   *
-   * @deprecated Use std::thread or std::jthread instead.
-   *
-   * @ingroup threads
-   */
-  template <typename RT, typename C, typename... Args>
-  DEAL_II_DEPRECATED inline Thread<RT>
-  new_thread(RT (C::*fun_ptr)(Args...) const,
-             std_cxx20::type_identity_t<const C> &c,
-             std_cxx20::type_identity_t<Args>... args)
-  {
-    // See the comment in the first new_thread() implementation
-    DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
-    // NOLINTNEXTLINE(modernize-avoid-bind) silence clang-tidy
-    return new_thread(std::function<RT()>(std::bind(
-      fun_ptr, std::cref(c), internal::maybe_make_ref<Args>::act(args)...)));
-    DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
-  }
-
-  // ------------------------ ThreadGroup -------------------------------------
-
-  /**
-   * A container for thread objects. Allows to add new thread objects and wait
-   * for them all together. The thread objects need to have the same return
-   * value for the called function.
-   *
-   * @ingroup threads
-   *
-   * @deprecated Use TaskGroup instead.
-   */
-  template <typename RT = void>
-  class DEAL_II_DEPRECATED ThreadGroup
-  {
-  public:
-    /**
-     * Add another thread object to the collection.
-     */
-    ThreadGroup &
-    operator+=(const Thread<RT> &t)
-    {
-      threads.push_back(t);
-      return *this;
-    }
-
-    /**
-     * Wait for all threads in the collection to finish. It is not a problem
-     * if some of them have already been waited for, i.e. you may call this
-     * function more than once, and you can also add new thread objects
-     * between subsequent calls to this function if you want.
-     */
-    void
-    join_all() const
-    {
-      for (auto &t : threads)
-        t.join();
-    }
-
-  private:
-    /**
-     * List of thread objects.
-     */
-    std::list<Thread<RT>> threads;
-  };
-
-
-  namespace internal
-  {
     /**
      * Set the value of a std::promise object by evaluating the action.
      *

diff --git a/tests/base/generate_normal_random_number_01.cc b/tests/base/generate_normal_random_number_01.cc
index ecc0f25bfbfe25fd093588bc2abf8ead12e6efad..c05caa49d2aa7533622b004144bd2f9e978db08e 100644 (file)
--- a/tests/base/generate_normal_random_number_01.cc
+++ b/tests/base/generate_normal_random_number_01.cc
@@ -54,23 +54,17 @@ main()
   initlog();
 
   // create 4 threads, run the test function on them
-  Threads::Thread<std::pair<double, double>> tg[4];
-  tg[0] = Threads::new_thread(&test);
-  tg[1] = Threads::new_thread(&test);
-  tg[2] = Threads::new_thread(&test);
-  tg[3] = Threads::new_thread(&test);
-
-  tg[0].join();
-  tg[1].join();
-  tg[2].join();
-  tg[3].join();
-
+  std::vector<std::future<std::pair<double, double>>> tg;
+  tg.push_back(std::async(&test));
+  tg.push_back(std::async(&test));
+  tg.push_back(std::async(&test));
+  tg.push_back(std::async(&test));
 
   // the random number generator is thread-local, so we should get the
   // same result every time
-  deallog << tg[0].return_value().first << ' ' << tg[0].return_value().second
-          << std::endl;
-  AssertThrow(tg[1].return_value() == tg[0].return_value(), ExcInternalError());
-  AssertThrow(tg[2].return_value() == tg[0].return_value(), ExcInternalError());
-  AssertThrow(tg[3].return_value() == tg[0].return_value(), ExcInternalError());
+  auto t0_result = tg[0].get();
+  deallog << t0_result.first << ' ' << t0_result.second << std::endl;
+  AssertThrow(tg[1].get() == t0_result, ExcInternalError());
+  AssertThrow(tg[2].get() == t0_result, ExcInternalError());
+  AssertThrow(tg[3].get() == t0_result, ExcInternalError());
 }

diff --git a/tests/bits/step-13.cc b/tests/bits/step-13.cc
index c4e6d812510646c36dea867210c986f1cf4639dc..4899bafa242652d9d4545566d170e8384e9acdd6 100644 (file)
--- a/tests/bits/step-13.cc
+++ b/tests/bits/step-13.cc
@@ -356,15 +356,15 @@ namespace LaplaceSolver
                                                    dof_handler.end(),
                                                    n_threads);
 
-    Threads::Mutex         mutex;
-    Threads::ThreadGroup<> threads;
+    Threads::Mutex           mutex;
+    std::vector<std::thread> threads;
     for (unsigned int thread = 0; thread < n_threads; ++thread)
-      threads += Threads::new_thread(&Solver<dim>::assemble_matrix,
-                                     *this,
-                                     linear_system,
-                                     thread_ranges[thread].first,
-                                     thread_ranges[thread].second,
-                                     mutex);
+      threads.emplace_back(&Solver<dim>::assemble_matrix,
+                           std::ref(*this),
+                           std::ref(linear_system),
+                           std::ref(thread_ranges[thread].first),
+                           std::ref(thread_ranges[thread].second),
+                           std::ref(mutex));
 
     assemble_rhs(linear_system.rhs);
     linear_system.hanging_node_constraints.condense(linear_system.rhs);
@@ -375,8 +375,9 @@ namespace LaplaceSolver
                                              *boundary_values,
                                              boundary_value_map);
 
+    for (auto &thread : threads)
+      thread.join();
 
-    threads.join_all();
     linear_system.hanging_node_constraints.condense(linear_system.matrix);
 
     MatrixTools::apply_boundary_values(boundary_value_map,
@@ -441,8 +442,10 @@ namespace LaplaceSolver
     void (*mhnc_p)(const DoFHandler<dim> &, AffineConstraints<double> &) =
       &DoFTools::make_hanging_node_constraints;
 
-    Threads::Thread<> mhnc_thread =
-      Threads::new_thread(mhnc_p, dof_handler, hanging_node_constraints);
+    std::thread mhnc_thread(
+      &DoFTools::make_hanging_node_constraints<dim, dim, double>,
+      std::ref(dof_handler),
+      std::ref(hanging_node_constraints));
 
     sparsity_pattern.reinit(dof_handler.n_dofs(),
                             dof_handler.n_dofs(),

diff --git a/tests/bits/step-14.cc b/tests/bits/step-14.cc
index b52fd53cadee8c290d275b15fd1236e0d5f6621d..4765aeb28362792bb828f5411dcc5014e9f55072 100644 (file)
--- a/tests/bits/step-14.cc
+++ b/tests/bits/step-14.cc
@@ -521,8 +521,9 @@ namespace LaplaceSolver
     void (*mhnc_p)(const DoFHandler<dim> &, AffineConstraints<double> &) =
       &DoFTools::make_hanging_node_constraints;
 
-    Threads::Thread<> mhnc_thread =
-      Threads::new_thread(mhnc_p, dof_handler, hanging_node_constraints);
+    std::thread mhnc_thread(mhnc_p,
+                            std::ref(dof_handler),
+                            std::ref(hanging_node_constraints));
 
     sparsity_pattern.reinit(dof_handler.n_dofs(),
                             dof_handler.n_dofs(),

diff --git a/tests/data_out/data_out_curved_cells.cc b/tests/data_out/data_out_curved_cells.cc
index 355edeb2948e1f600fe0cd72612d447cba51f14b..35a4245915d967cdb9f3d5054b5f2f14998ffe8e 100644 (file)
--- a/tests/data_out/data_out_curved_cells.cc
+++ b/tests/data_out/data_out_curved_cells.cc
@@ -200,10 +200,14 @@ curved_grid(std::ostream &out)
   for (unsigned int i = 0; i < 2; ++i)
     us[i].reinit(dof_handler.n_dofs());
   // solve linear systems in parallel
-  Threads::ThreadGroup<> threads;
+  std::vector<std::thread> threads;
   for (unsigned int i = 0; i < 2; ++i)
-    threads += Threads::new_thread(&laplace_solve, S, m[i], us[i]);
-  threads.join_all();
+    threads.emplace_back(&laplace_solve,
+                         std::ref(S),
+                         std::ref(m[i]),
+                         std::ref(us[i]));
+  threads[0].join();
+  threads[1].join();
   // create a new DoFHandler for the combined
   // system
   FESystem<2>   cfe(FE_Q<2>(2), 2);

diff --git a/tests/fail/hp-step-14.cc b/tests/fail/hp-step-14.cc
index 53ed0c2900c26e46e2dbe4d56193eef7d656b87b..fe507ce4ef9c9062911a0fce38f6f9c4b2c6b615 100644 (file)
--- a/tests/fail/hp-step-14.cc
+++ b/tests/fail/hp-step-14.cc
@@ -447,15 +447,15 @@ namespace LaplaceSolver
                                                    dof_handler.end(),
                                                    n_threads);
 
-    Threads::Mutex         mutex;
-    Threads::ThreadGroup<> threads;
+    Threads::Mutex           mutex;
+    std::vector<std::thread> threads;
     for (unsigned int thread = 0; thread < n_threads; ++thread)
-      threads += Threads::new_thread(&Solver<dim>::assemble_matrix,
-                                     *this,
-                                     linear_system,
-                                     thread_ranges[thread].first,
-                                     thread_ranges[thread].second,
-                                     mutex);
+      threads.emplace_back(&Solver<dim>::assemble_matrix,
+                           std::ref(*this),
+                           std::ref(linear_system),
+                           std::ref(thread_ranges[thread].first),
+                           std::ref(thread_ranges[thread].second),
+                           std::ref(mutex));
 
     assemble_rhs(linear_system.rhs);
     linear_system.hanging_node_constraints.condense(linear_system.rhs);
@@ -532,8 +532,7 @@ namespace LaplaceSolver
     void (*mhnc_p)(const DoFHandler<dim> &, AffineConstraints<double> &) =
       &DoFTools::make_hanging_node_constraints;
 
-    Threads::Thread<> mhnc_thread =
-      Threads::new_thread(mhnc_p, dof_handler, hanging_node_constraints);
+    std::thread mhnc_thread(mhnc_p, dof_handler, hanging_node_constraints);
 
     sparsity_pattern.reinit(dof_handler.n_dofs(),
                             dof_handler.n_dofs(),
@@ -1526,12 +1525,11 @@ namespace LaplaceSolver
   void
   WeightedResidual<dim>::solve_problem()
   {
-    Threads::ThreadGroup<> threads;
-    threads +=
-      Threads::new_thread(&WeightedResidual<dim>::solve_primal_problem, *this);
-    threads +=
-      Threads::new_thread(&WeightedResidual<dim>::solve_dual_problem, *this);
-    threads.join_all();
+    std::vector<std::thread> threads;
+    threads.emplace_back(&WeightedResidual<dim>::solve_primal_problem, *this);
+    threads.emplace_back(&WeightedResidual<dim>::solve_dual_problem, *this);
+    threads[0].join();
+    threads[1].join();
   }
 
 
@@ -1663,18 +1661,19 @@ namespace LaplaceSolver
     error_indicators.reinit(
       dual_solver.dof_handler.get_triangulation().n_active_cells());
 
-    const unsigned int     n_threads = MultithreadInfo::n_threads();
-    Threads::ThreadGroup<> threads;
+    const unsigned int       n_threads = MultithreadInfo::n_threads();
+    std::vector<std::thread> threads;
     for (unsigned int i = 0; i < n_threads; ++i)
-      threads += Threads::new_thread(&WeightedResidual<dim>::estimate_some,
-                                     *this,
-                                     primal_solution,
-                                     dual_weights,
-                                     n_threads,
-                                     i,
-                                     error_indicators,
-                                     face_integrals);
-    threads.join_all();
+      threads.emplace_back(&WeightedResidual<dim>::estimate_some,
+                           *this,
+                           primal_solution,
+                           dual_weights,
+                           n_threads,
+                           i,
+                           error_indicators,
+                           face_integrals);
+    for (auto &thread : threads)
+      thread.join();
 
     unsigned int present_cell = 0;
     for (active_cell_iterator cell = dual_solver.dof_handler.begin_active();

diff --git a/tests/hp/step-13.cc b/tests/hp/step-13.cc
index 28ee0daa7fcee2ee466543b1308fe5d81edb5f16..3e607afbf6bcb18d18b93970d8d258d19e43dec9 100644 (file)
--- a/tests/hp/step-13.cc
+++ b/tests/hp/step-13.cc
@@ -359,15 +359,15 @@ namespace LaplaceSolver
                                                    dof_handler.end(),
                                                    n_threads);
 
-    Threads::Mutex         mutex;
-    Threads::ThreadGroup<> threads;
+    Threads::Mutex           mutex;
+    std::vector<std::thread> threads;
     for (unsigned int thread = 0; thread < n_threads; ++thread)
-      threads += Threads::new_thread(&Solver<dim>::assemble_matrix,
-                                     *this,
-                                     linear_system,
-                                     thread_ranges[thread].first,
-                                     thread_ranges[thread].second,
-                                     mutex);
+      threads.emplace_back(&Solver<dim>::assemble_matrix,
+                           std::ref(*this),
+                           std::ref(linear_system),
+                           std::ref(thread_ranges[thread].first),
+                           std::ref(thread_ranges[thread].second),
+                           std::ref(mutex));
 
     assemble_rhs(linear_system.rhs);
     linear_system.hanging_node_constraints.condense(linear_system.rhs);
@@ -378,8 +378,8 @@ namespace LaplaceSolver
                                              *boundary_values,
                                              boundary_value_map);
 
-
-    threads.join_all();
+    for (auto &thread : threads)
+      thread.join();
     linear_system.hanging_node_constraints.condense(linear_system.matrix);
 
     MatrixTools::apply_boundary_values(boundary_value_map,
@@ -446,8 +446,9 @@ namespace LaplaceSolver
     void (*mhnc_p)(const DoFHandler<dim> &, AffineConstraints<double> &) =
       &DoFTools::make_hanging_node_constraints;
 
-    Threads::Thread<> mhnc_thread =
-      Threads::new_thread(mhnc_p, dof_handler, hanging_node_constraints);
+    std::thread mhnc_thread(mhnc_p,
+                            std::ref(dof_handler),
+                            std::ref(hanging_node_constraints));
 
     sparsity_pattern.reinit(dof_handler.n_dofs(),
                             dof_handler.n_dofs(),

diff --git a/tests/lac/block_matrices_02.cc b/tests/lac/block_matrices_02.cc
index 97c3fa28d85d0f23f886a880d3e6770be2641680..29db84876d378fd5b8184741ff9abc88bc769d21 100644 (file)
--- a/tests/lac/block_matrices_02.cc
+++ b/tests/lac/block_matrices_02.cc
@@ -78,13 +78,14 @@ test()
 
   BlockSparseMatrix<double> bsm(bsp);
 
-  Threads::ThreadGroup<> tg;
+  std::vector<std::thread> tg;
   for (unsigned int i = 0; i < 100; ++i)
     {
-      tg += Threads::new_thread(&do_set, true, bsm);
-      tg += Threads::new_thread(&do_set, false, bsm);
+      tg.emplace_back(&do_set, true, std::ref(bsm));
+      tg.emplace_back(&do_set, false, std::ref(bsm));
     }
-  tg.join_all();
+  for (auto &thread : tg)
+    thread.join();
 
   bsm.print_formatted(deallog.get_file_stream());
 }

diff --git a/tests/lac/block_matrices_03.cc b/tests/lac/block_matrices_03.cc
index 01928af4b07cd5e7977aa003b45a6ae7c7ad4a3d..1132b508b2d87eea374e295a10899604f6e1323c 100644 (file)
--- a/tests/lac/block_matrices_03.cc
+++ b/tests/lac/block_matrices_03.cc
@@ -78,13 +78,14 @@ test()
 
   BlockSparseMatrix<double> bsm(bsp);
 
-  Threads::ThreadGroup<> tg;
+  std::vector<std::thread> tg;
   for (unsigned int i = 0; i < 100; ++i)
     {
-      tg += Threads::new_thread(&do_add, true, bsm);
-      tg += Threads::new_thread(&do_add, false, bsm);
+      tg.emplace_back(&do_add, true, std::ref(bsm));
+      tg.emplace_back(&do_add, false, std::ref(bsm));
     }
-  tg.join_all();
+  for (auto &thread : tg)
+    thread.join();
 
   // divide whole matrix by 100 to get back to the effect of a single set
   bsm /= 100;

diff --git a/tests/multithreading/task_06.cc b/tests/multithreading/task_06.cc
index cfac0fd359df7af43dcf5beee70cf96ae35cbf5b..c82cd68dd4bae785941aab4aa8491720419cb832 100644 (file)
--- a/tests/multithreading/task_06.cc
+++ b/tests/multithreading/task_06.cc
@@ -42,8 +42,8 @@ main()
   initlog();
 
   {
-    Threads::Thread<> t1 = Threads::new_thread(test, 1);
-    Threads::Thread<> t2 = Threads::new_thread(test, 2);
+    std::thread t1(test, 1);
+    std::thread t2(test, 2);
 
     t1.join();
     t2.join();

diff --git a/tests/multithreading/thread_12.cc b/tests/multithreading/thread_12.cc
index 825d2ebf4d15e285063b6bddd8a0d8b95531b3d4..ad22fa9fa110ee8d9d1fc23f60ee266a02a9e097 100644 (file)
--- a/tests/multithreading/thread_12.cc
+++ b/tests/multithreading/thread_12.cc
@@ -41,11 +41,12 @@ main()
 {
   initlog();
 
-  Threads::ThreadGroup<double> tg;
-  tg += Threads::new_thread(std::bind(test, 1));
-  tg += Threads::new_thread([]() { return test(2); });
+  std::vector<std::thread> tg;
+  tg.emplace_back(std::bind(test, 1));
+  tg.emplace_back([]() { return test(2); });
 
-  tg.join_all();
+  tg[0].join();
+  tg[1].join();
 
   deallog << "OK" << std::endl;
 

diff --git a/tests/multithreading/thread_local_storage_01.cc b/tests/multithreading/thread_local_storage_01.cc
index 4d75b0a0d6e8e56a0f9bc98b04b927e81c585b71..3c37171912220e5c0064c89ebfabae960c9f927a 100644 (file)
--- a/tests/multithreading/thread_local_storage_01.cc
+++ b/tests/multithreading/thread_local_storage_01.cc
@@ -71,9 +71,9 @@ test()
   // thread ids, which means that we will
   // create 5 individual thread specific
   // storage locations
-  Threads::ThreadGroup<> tg;
+  std::vector<std::thread> tg;
   for (unsigned int i = 10; i < 15; ++i)
-    tg += Threads::new_thread(execute, i);
+    tg.emplace_back(execute, i);
 
   // spin lock until all threads have created
   // their objects
@@ -97,7 +97,8 @@ test()
   deallog << "Done." << std::endl;
 
   // now make sure the threads all finish
-  tg.join_all();
+  for (auto &thread : tg)
+    thread.join();
 }
 
 

diff --git a/tests/multithreading/thread_local_storage_02.cc b/tests/multithreading/thread_local_storage_02.cc
index 90da68778afa02ed276974209254f8d42d4395c9..2326869d40d174b556c8f38ddcf15453b40e299b 100644 (file)
--- a/tests/multithreading/thread_local_storage_02.cc
+++ b/tests/multithreading/thread_local_storage_02.cc
@@ -82,9 +82,9 @@ test()
   // thread ids, which means that we will
   // create 5 individual thread specific
   // storage locations
-  Threads::ThreadGroup<> tg;
+  std::vector<std::thread> tg;
   for (unsigned int i = 10; i < 15; ++i)
-    tg += Threads::new_thread(execute, i);
+    tg.emplace_back(execute, i);
 
   // spin lock until all threads have created
   // their objects
@@ -109,7 +109,8 @@ test()
   deallog << "Done." << std::endl;
 
   // now make sure the threads all finish
-  tg.join_all();
+  for (auto &thread : tg)
+    thread.join();
 
   // at this point, the seventh object will
   // be destroyed, which is the exemplar

diff --git a/tests/multithreading/thread_local_storage_03.cc b/tests/multithreading/thread_local_storage_03.cc
index 3b9e15a002f16a86517dc2034dbe656a0412b8bb..028d48b62e04860076ff9f420c5e0c65f1e9d133 100644 (file)
--- a/tests/multithreading/thread_local_storage_03.cc
+++ b/tests/multithreading/thread_local_storage_03.cc
@@ -45,11 +45,10 @@ struct X
 void
 test()
 {
-  X                    x;
-  Threads::Thread<int> t;
-  t = Threads::new_thread(&X::f, x);
+  X    x;
+  auto future = std::async(&X::f, x);
 
-  AssertThrow(t.return_value() == 42, ExcInternalError());
+  AssertThrow(future.get() == 42, ExcInternalError());
 }
 
 

diff --git a/tests/multithreading/thread_local_storage_04.cc b/tests/multithreading/thread_local_storage_04.cc
index b2c94ff3a6445c2fbfa17013902d214b7d63f5e6..c86252e960e56cea410a21414d13ed242e4381c9 100644 (file)
--- a/tests/multithreading/thread_local_storage_04.cc
+++ b/tests/multithreading/thread_local_storage_04.cc
@@ -50,14 +50,12 @@ test()
 {
   X x;
   {
-    Threads::Thread<int> t;
-    t = Threads::new_thread(&X::f, x);
-    AssertThrow(t.return_value() == 10, ExcInternalError());
+    auto future = std::async(&X::f, x);
+    AssertThrow(future.get() == 10, ExcInternalError());
   }
   {
-    Threads::Thread<int> t;
-    t = Threads::new_thread(&X::f, x);
-    AssertThrow(t.return_value() == 11, ExcInternalError());
+    auto future = std::async(&X::f, x);
+    AssertThrow(future.get() == 11, ExcInternalError());
   }
 
   AssertThrow(counter == 12, ExcInternalError());

diff --git a/tests/multithreading/thread_local_storage_05.cc b/tests/multithreading/thread_local_storage_05.cc
index 82ceecf640dd72c073b9a5e0770b895e0502b507..bbb6f4bc3aa57bce2485440ad39e9ea1d6780427 100644 (file)
--- a/tests/multithreading/thread_local_storage_05.cc
+++ b/tests/multithreading/thread_local_storage_05.cc
@@ -69,11 +69,11 @@ test()
   Threads::Mutex     m[N];
 
   // start N threads with mutexes locked
-  Threads::ThreadGroup<> tg;
+  std::thread tg[N];
   for (unsigned int i = 0; i < N; ++i)
     {
       m[i].lock();
-      tg += Threads::new_thread(execute, m[i]);
+      tg[i] = std::thread(execute, std::ref(m[i]));
     }
 
   // let threads work through their first part
@@ -86,7 +86,8 @@ test()
     m[i].unlock();
 
   // now make sure the threads all finish
-  tg.join_all();
+  for (auto &thread : tg)
+    thread.join();
 
   deallog << "OK" << std::endl;
 }

diff --git a/tests/multithreading/thread_local_storage_06.cc b/tests/multithreading/thread_local_storage_06.cc
index 3dc1ce50206caaddaf927b2b433dae5dd6e0f639..9137283baf4821b0cab46b9a6f4a61463e0016ef 100644 (file)
--- a/tests/multithreading/thread_local_storage_06.cc
+++ b/tests/multithreading/thread_local_storage_06.cc
@@ -81,11 +81,11 @@ test()
   Threads::Mutex     m[N];
 
   // start N threads with mutexes locked
-  Threads::ThreadGroup<> tg;
+  std::vector<std::thread> tg;
   for (unsigned int i = 0; i < N; ++i)
     {
       m[i].lock();
-      tg += Threads::new_thread(execute, m[i]);
+      tg.emplace_back(execute, std::ref(m[i]));
     }
 
   // let threads work through their first part
@@ -98,7 +98,8 @@ test()
     m[i].unlock();
 
   // now make sure the threads all finish
-  tg.join_all();
+  for (auto &thread : tg)
+    thread.join();
 
   deallog << "OK" << std::endl;
 }

diff --git a/tests/multithreading/thread_local_storage_07.cc b/tests/multithreading/thread_local_storage_07.cc
index f53e0830032404de68d1dbca46007ff0b7ea956b..feb405c1088a1b1a5b575291b451ca73305cf791 100644 (file)
--- a/tests/multithreading/thread_local_storage_07.cc
+++ b/tests/multithreading/thread_local_storage_07.cc
@@ -60,12 +60,13 @@ test()
   // thread ids, which means that we will
   // create 5 individual thread specific
   // storage locations
-  Threads::ThreadGroup<> tg;
+  std::vector<std::thread> tg;
   for (unsigned int i = 10; i < 15; ++i)
-    tg += Threads::new_thread(execute, i);
+    tg.emplace_back(execute, i);
 
   // now make sure the threads all finish
-  tg.join_all();
+  for (auto &thread : tg)
+    thread.join();
 }
 
 

diff --git a/tests/multithreading/thread_local_storage_08.cc b/tests/multithreading/thread_local_storage_08.cc
index 0079576b044fcc3cb0235be2989fa9052ea8f0e6..092078a88870c2dfefdefc2e69d3f34aa7130cd6 100644 (file)
--- a/tests/multithreading/thread_local_storage_08.cc
+++ b/tests/multithreading/thread_local_storage_08.cc
@@ -60,12 +60,13 @@ test()
   // thread ids, which means that we will
   // create 5 individual thread specific
   // storage locations
-  Threads::ThreadGroup<> tg;
+  std::vector<std::thread> tg;
   for (unsigned int i = 10; i < 15; ++i)
-    tg += Threads::new_thread(execute, i);
+    tg.emplace_back(execute, i);
 
   // now make sure the threads all finish
-  tg.join_all();
+  for (auto &thread : tg)
+    thread.join();
 }
 
 

diff --git a/tests/multithreading/thread_validity_01.cc b/tests/multithreading/thread_validity_01.cc
deleted file mode 100644 (file)
index 1849e41..0000000
--- a/tests/multithreading/thread_validity_01.cc
+++ /dev/null
@@ -1,62 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2008 - 2020 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE.md at
-// the top level directory of deal.II.
-//
-// ---------------------------------------------------------------------
-
-
-// test that objects that can't be copied aren't copied when passed to a new
-// thread by reference
-
-#include <deal.II/base/thread_management.h>
-
-#include "../tests.h"
-
-struct X
-{
-  X(int i)
-    : i(i)
-  {}
-  int i;
-
-private:
-  X(const X &);
-  X &
-  operator=(const X &);
-};
-
-
-void
-execute(const X &x)
-{
-  AssertThrow(x.i == 42, ExcInternalError());
-  deallog << "OK" << std::endl;
-}
-
-
-void
-test()
-{
-  X                     x(42);
-  Threads::Thread<void> t = Threads::new_thread(&execute, x);
-  t.join();
-}
-
-
-
-int
-main()
-{
-  initlog();
-
-  test();
-}

diff --git a/tests/multithreading/thread_validity_01.output b/tests/multithreading/thread_validity_01.output
deleted file mode 100644 (file)
index 0fd8fc1..0000000
--- a/tests/multithreading/thread_validity_01.output
+++ /dev/null
@@ -1,2 +0,0 @@
-
-DEAL::OK

diff --git a/tests/multithreading/thread_validity_02.cc b/tests/multithreading/thread_validity_02.cc
deleted file mode 100644 (file)
index c332100..0000000
--- a/tests/multithreading/thread_validity_02.cc
+++ /dev/null
@@ -1,66 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2008 - 2020 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE.md at
-// the top level directory of deal.II.
-//
-// ---------------------------------------------------------------------
-
-
-// test that objects that can't be copied aren't copied when passed to a new
-// thread by reference
-//
-// test here with a constant object to which no non-const reference can be
-// bound
-
-
-#include <deal.II/base/thread_management.h>
-
-#include "../tests.h"
-
-struct X
-{
-  X(int i)
-    : i(i)
-  {}
-  int i;
-
-private:
-  X(const X &);
-  X &
-  operator=(const X &);
-};
-
-
-void
-execute(const X &x)
-{
-  AssertThrow(x.i == 42, ExcInternalError());
-  deallog << "OK" << std::endl;
-}
-
-
-void
-test()
-{
-  const X               x(42);
-  Threads::Thread<void> t = Threads::new_thread(&execute, x);
-  t.join();
-}
-
-
-
-int
-main()
-{
-  initlog();
-
-  test();
-}

diff --git a/tests/multithreading/thread_validity_02.output b/tests/multithreading/thread_validity_02.output
deleted file mode 100644 (file)
index 0fd8fc1..0000000
--- a/tests/multithreading/thread_validity_02.output
+++ /dev/null
@@ -1,2 +0,0 @@
-
-DEAL::OK

diff --git a/tests/multithreading/thread_validity_03.cc b/tests/multithreading/thread_validity_03.cc
deleted file mode 100644 (file)
index f248b60..0000000
--- a/tests/multithreading/thread_validity_03.cc
+++ /dev/null
@@ -1,65 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2008 - 2020 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE.md at
-// the top level directory of deal.II.
-//
-// ---------------------------------------------------------------------
-
-
-// test that objects that can't be copied aren't copied when passed to a new
-// thread by reference
-//
-// this is a variant that makes sure that member functions of objects that
-// can't be copied aren't called on copies
-
-#include <deal.II/base/thread_management.h>
-
-#include "../tests.h"
-
-struct X
-{
-  X(int i)
-    : i(i)
-  {}
-  int i;
-
-  void
-  execute()
-  {
-    Assert(i == 42, ExcInternalError());
-    deallog << "OK" << std::endl;
-  }
-
-private:
-  X(const X &);
-  X &
-  operator=(const X &);
-};
-
-
-
-void
-test()
-{
-  X                     x(42);
-  Threads::Thread<void> t = Threads::new_thread(&X::execute, x);
-  t.join();
-}
-
-
-
-int
-main()
-{
-  initlog();
-
-  test();
-}

diff --git a/tests/multithreading/thread_validity_03.output b/tests/multithreading/thread_validity_03.output
deleted file mode 100644 (file)
index 0fd8fc1..0000000
--- a/tests/multithreading/thread_validity_03.output
+++ /dev/null
@@ -1,2 +0,0 @@
-
-DEAL::OK

diff --git a/tests/multithreading/thread_validity_04.cc b/tests/multithreading/thread_validity_04.cc
deleted file mode 100644 (file)
index 893ddec..0000000
--- a/tests/multithreading/thread_validity_04.cc
+++ /dev/null
@@ -1,66 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2008 - 2020 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE.md at
-// the top level directory of deal.II.
-//
-// ---------------------------------------------------------------------
-
-
-// test that objects that can't be copied aren't copied when passed to a new
-// thread by reference
-//
-// this is a variant that makes sure that member functions of objects that
-// can't be copied aren't called on copies. this test is for const member
-// functions
-
-#include <deal.II/base/thread_management.h>
-
-#include "../tests.h"
-
-struct X
-{
-  X(int i)
-    : i(i)
-  {}
-  int i;
-
-  void
-  execute() const
-  {
-    Assert(i == 42, ExcInternalError());
-    deallog << "OK" << std::endl;
-  }
-
-private:
-  X(const X &);
-  X &
-  operator=(const X &);
-};
-
-
-
-void
-test()
-{
-  const X               x(42);
-  Threads::Thread<void> t = Threads::new_thread(&X::execute, x);
-  t.join();
-}
-
-
-
-int
-main()
-{
-  initlog();
-
-  test();
-}

diff --git a/tests/multithreading/thread_validity_04.output b/tests/multithreading/thread_validity_04.output
deleted file mode 100644 (file)
index 0fd8fc1..0000000
--- a/tests/multithreading/thread_validity_04.output
+++ /dev/null
@@ -1,2 +0,0 @@
-
-DEAL::OK

diff --git a/tests/multithreading/thread_validity_05.cc b/tests/multithreading/thread_validity_05.cc
deleted file mode 100644 (file)
index a9e062a..0000000
--- a/tests/multithreading/thread_validity_05.cc
+++ /dev/null
@@ -1,107 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2008 - 2020 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE.md at
-// the top level directory of deal.II.
-//
-// ---------------------------------------------------------------------
-
-
-// test that objects that can't be copied aren't copied when passed to a new
-// thread by reference
-//
-// this is a variant that makes sure that if there are const and non-const
-// member functions that the correct one is called
-
-#include <deal.II/base/thread_management.h>
-
-#include "../tests.h"
-
-struct X
-{
-  X(int i)
-    : i(i)
-  {}
-  int i;
-
-  void
-  execute()
-  {
-    Assert(false, ExcInternalError());
-  }
-
-  void
-  execute() const
-  {
-    Assert(i == 42, ExcInternalError());
-    deallog << "OK" << std::endl;
-  }
-
-private:
-  X(const X &);
-  X &
-  operator=(const X &);
-};
-
-
-void
-test1()
-{
-  const X               x(42);
-  Threads::Thread<void> t = Threads::new_thread(&X::execute, x);
-  t.join();
-}
-
-
-struct Y
-{
-  Y(int i)
-    : i(i)
-  {}
-  int i;
-
-  void
-  execute()
-  {
-    Assert(i == 42, ExcInternalError());
-    deallog << "OK" << std::endl;
-  }
-
-  void
-  execute() const
-  {
-    Assert(false, ExcInternalError());
-  }
-
-private:
-  Y(const Y &);
-  Y &
-  operator=(const Y &);
-};
-
-
-void
-test2()
-{
-  Y                     y(42);
-  Threads::Thread<void> t = Threads::new_thread(&Y::execute, y);
-  t.join();
-}
-
-
-
-int
-main()
-{
-  initlog();
-
-  test1();
-  test2();
-}

diff --git a/tests/multithreading/thread_validity_05.output b/tests/multithreading/thread_validity_05.output
deleted file mode 100644 (file)
index 8b3b075..0000000
--- a/tests/multithreading/thread_validity_05.output
+++ /dev/null
@@ -1,3 +0,0 @@
-
-DEAL::OK
-DEAL::OK

diff --git a/tests/multithreading/thread_validity_06.cc b/tests/multithreading/thread_validity_06.cc
deleted file mode 100644 (file)
index 1732f98..0000000
--- a/tests/multithreading/thread_validity_06.cc
+++ /dev/null
@@ -1,89 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2008 - 2020 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE.md at
-// the top level directory of deal.II.
-//
-// ---------------------------------------------------------------------
-
-
-// this is a test opposite of thread_validity_05: if we have a function that
-// gets an argument *by value* rather than by reference, then make sure that
-// it is actually copied when passed to a new thread by reference
-//
-// deal.II does not guarantee how often an argument is copied, but it has to
-// be copied at least once from the calling thread to the stack of the called
-// thread
-
-#include <deal.II/base/thread_management.h>
-
-#include "../tests.h"
-
-struct X
-{
-  X()
-    : i(0)
-  {}
-  X(const X &x)
-    : i(x.i + 1)
-  {}
-  X &
-  operator=(const X &x)
-  {
-    i = x.i + 1;
-    return *this;
-  }
-  int i;
-};
-
-
-void
-execute_ref(const X &x)
-{
-  Assert(x.i == 0, ExcInternalError());
-  deallog << unify_pretty_function(__PRETTY_FUNCTION__) << ' ' << x.i
-          << std::endl;
-  deallog << "OK" << std::endl;
-}
-
-void
-execute_value(X x)
-{
-  Assert(x.i > 0, ExcInternalError());
-  deallog << unify_pretty_function(__PRETTY_FUNCTION__) << ' '
-          << (x.i > 0 ? "OK" : "not OK") << std::endl;
-  deallog << "OK" << std::endl;
-}
-
-
-void
-test()
-{
-  {
-    X                     x;
-    Threads::Thread<void> t = Threads::new_thread(&execute_ref, x);
-    t.join();
-  }
-  {
-    X                     x;
-    Threads::Thread<void> t = Threads::new_thread(&execute_value, x);
-    t.join();
-  }
-}
-
-
-
-int
-main()
-{
-  initlog();
-
-  test();
-}

diff --git a/tests/multithreading/thread_validity_06.output b/tests/multithreading/thread_validity_06.output
deleted file mode 100644 (file)
index cf43838..0000000
--- a/tests/multithreading/thread_validity_06.output
+++ /dev/null
@@ -1,5 +0,0 @@
-
-DEAL::void execute_ref(const X&) 0
-DEAL::OK
-DEAL::void execute_value(X) OK
-DEAL::OK

diff --git a/tests/multithreading/thread_validity_07.cc b/tests/multithreading/thread_validity_07.cc
deleted file mode 100644 (file)
index 1f133b0..0000000
--- a/tests/multithreading/thread_validity_07.cc
+++ /dev/null
@@ -1,65 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2008 - 2020 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE.md at
-// the top level directory of deal.II.
-//
-// ---------------------------------------------------------------------
-
-
-// test that if multiple threads are waiting for one single thread, all of the
-// waiting ones will be woken up.
-
-#include <deal.II/base/thread_management.h>
-
-#include "../tests.h"
-
-
-void
-worker()
-{
-  deallog << "Worker thread is starting." << std::endl;
-  std::this_thread::sleep_for(std::chrono::seconds(3));
-  deallog << "Worker thread is finished." << std::endl;
-}
-
-Threads::Thread<> worker_thread;
-
-void
-waiter(int i)
-{
-  worker_thread.join();
-
-  deallog << "Waiting thread " << i << " was woken up." << std::endl;
-}
-
-
-
-int
-main()
-{
-  initlog();
-
-  worker_thread = Threads::new_thread(worker);
-
-  Threads::ThreadGroup<> waiter_threads;
-  for (unsigned int i = 0; i < 20; ++i)
-    waiter_threads += Threads::new_thread(waiter, i);
-
-  waiter_threads.join_all();
-  deallog << "All waiting threads finished." << std::endl;
-
-  std::ofstream *out_stream =
-    dynamic_cast<std::ofstream *>(&deallog.get_file_stream());
-  Assert(out_stream != nullptr, ExcInternalError());
-  deallog.detach();
-  out_stream->close();
-  sort_file_contents("output");
-}

diff --git a/tests/multithreading/thread_validity_07.output b/tests/multithreading/thread_validity_07.output
deleted file mode 100644 (file)
index f0748e5..0000000
--- a/tests/multithreading/thread_validity_07.output
+++ /dev/null
@@ -1,24 +0,0 @@
-DEAL::All waiting threads finished.
-DEAL::Waiting thread 0 was woken up.
-DEAL::Waiting thread 1 was woken up.
-DEAL::Waiting thread 10 was woken up.
-DEAL::Waiting thread 11 was woken up.
-DEAL::Waiting thread 12 was woken up.
-DEAL::Waiting thread 13 was woken up.
-DEAL::Waiting thread 14 was woken up.
-DEAL::Waiting thread 15 was woken up.
-DEAL::Waiting thread 16 was woken up.
-DEAL::Waiting thread 17 was woken up.
-DEAL::Waiting thread 18 was woken up.
-DEAL::Waiting thread 19 was woken up.
-DEAL::Waiting thread 2 was woken up.
-DEAL::Waiting thread 3 was woken up.
-DEAL::Waiting thread 4 was woken up.
-DEAL::Waiting thread 5 was woken up.
-DEAL::Waiting thread 6 was woken up.
-DEAL::Waiting thread 7 was woken up.
-DEAL::Waiting thread 8 was woken up.
-DEAL::Waiting thread 9 was woken up.
-DEAL::Worker thread is finished.
-DEAL::Worker thread is starting.
-

diff --git a/tests/multithreading/thread_validity_08.cc b/tests/multithreading/thread_validity_08.cc
deleted file mode 100644 (file)
index 7c932ff..0000000
--- a/tests/multithreading/thread_validity_08.cc
+++ /dev/null
@@ -1,74 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2008 - 2020 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE.md at
-// the top level directory of deal.II.
-//
-// ---------------------------------------------------------------------
-
-
-// see if we can detach from threads
-
-#include <deal.II/base/thread_management.h>
-
-#include <atomic>
-
-#include "../tests.h"
-
-
-Threads::Mutex          mutex;
-static std::atomic<int> spin_lock(0);
-
-
-void
-worker()
-{
-  // wait for the mutex to make sure the main
-  // thread has already moved on. we can immediately
-  // release the mutex again.
-  mutex.lock();
-  mutex.unlock();
-  deallog << "OK." << std::endl;
-  spin_lock = 1;
-}
-
-
-
-int
-main()
-{
-  initlog();
-
-  mutex.lock();
-  // start and abandon the
-  // thread. because we hold the
-  // lock, the started task can not
-  // proceed to print out "OK" until
-  // we release the lock which we do
-  // only after some time to give the
-  // thread a way to start up
-  //
-  // if detachment from threads isn't
-  // possible, then the worker()
-  // function will hang because it
-  // won't be able to acquire the
-  // mutex
-  {
-    Threads::new_thread(worker);
-  }
-  std::this_thread::sleep_for(std::chrono::seconds(1));
-
-  // let abandoned thread continue
-  mutex.unlock();
-
-  // wait for thread to finish
-  while (spin_lock == 0)
-    ;
-}

diff --git a/tests/multithreading/thread_validity_08.output b/tests/multithreading/thread_validity_08.output
deleted file mode 100644 (file)
index 56034c8..0000000
--- a/tests/multithreading/thread_validity_08.output
+++ /dev/null
@@ -1,2 +0,0 @@
-
-DEAL::OK.

diff --git a/tests/multithreading/thread_validity_09.cc b/tests/multithreading/thread_validity_09.cc
deleted file mode 100644 (file)
index 1a8407c..0000000
--- a/tests/multithreading/thread_validity_09.cc
+++ /dev/null
@@ -1,77 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2008 - 2020 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE.md at
-// the top level directory of deal.II.
-//
-// ---------------------------------------------------------------------
-
-
-// see if we can detach from threads. before r18272 we used to have a
-// bug where detached threads would write their return value into
-// released memory. this test releases memory, allocates it again,
-// and makes sure nobody writes into it at undue times
-
-#include <deal.II/base/thread_management.h>
-
-#include <atomic>
-
-#include "../tests.h"
-
-
-Threads::Mutex          mutex;
-static std::atomic<int> spin_lock(0);
-
-
-int
-worker()
-{
-  // wait till the main thread has actually done its work -- we will
-  // hang in the 'acquire' line until the main thread releases the
-  // mutex. release the mutex again at the end of this function since
-  // mutices can only be released on the same thread as they are
-  // acquired on.
-  mutex.lock();
-  deallog << "OK." << std::endl;
-  spin_lock = 1;
-  mutex.unlock();
-  return 42;
-}
-
-
-
-int
-main()
-{
-  initlog();
-
-  mutex.lock();
-  {
-    Threads::new_thread(worker);
-  }
-  std::this_thread::sleep_for(std::chrono::seconds(1));
-
-  const unsigned int sz = 1000000;
-  char *             p  = new char[sz];
-  for (unsigned int i = 0; i < sz; ++i)
-    p[i] = 0;
-
-  // make sure the worker thread can actually start
-  mutex.unlock();
-
-  // wait for the worker thread to do its work
-  while (spin_lock == 0)
-    ;
-
-  for (unsigned int i = 0; i < sz; ++i)
-    AssertThrow(p[i] == 0, ExcInternalError());
-
-  delete[] p;
-}

diff --git a/tests/multithreading/thread_validity_09.output b/tests/multithreading/thread_validity_09.output
deleted file mode 100644 (file)
index 56034c8..0000000
--- a/tests/multithreading/thread_validity_09.output
+++ /dev/null
@@ -1,2 +0,0 @@
-
-DEAL::OK.

diff --git a/tests/multithreading/thread_validity_10.cc b/tests/multithreading/thread_validity_10.cc
deleted file mode 100644 (file)
index 9edc385..0000000
--- a/tests/multithreading/thread_validity_10.cc
+++ /dev/null
@@ -1,52 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2008 - 2020 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE.md at
-// the top level directory of deal.II.
-//
-// ---------------------------------------------------------------------
-
-
-// see that we can query a thread object that has never been
-// assigned
-
-#include <deal.II/base/thread_management.h>
-
-#include "../tests.h"
-
-
-Threads::Mutex mutex;
-int            spin_lock = 0;
-
-
-int
-worker()
-{
-  std::this_thread::sleep_for(std::chrono::seconds(1));
-  return 42;
-}
-
-
-
-int
-main()
-{
-  initlog();
-
-  Threads::Thread<int> t;
-  // join non-existing thread
-  deallog << (t.valid() ? "true" : "false") << std::endl;
-
-  // now assign a thread object and
-  // wait for it
-  t = Threads::new_thread(worker);
-  deallog << (t.valid() ? "true" : "false") << std::endl;
-  deallog << "return value = " << t.return_value() << std::endl;
-}

diff --git a/tests/multithreading/thread_validity_10.output b/tests/multithreading/thread_validity_10.output
deleted file mode 100644 (file)
index c5d5f5d..0000000
--- a/tests/multithreading/thread_validity_10.output
+++ /dev/null
@@ -1,4 +0,0 @@
-
-DEAL::false
-DEAL::true
-DEAL::return value = 42

diff --git a/tests/multithreading/thread_validity_11.cc b/tests/multithreading/thread_validity_11.cc
deleted file mode 100644 (file)
index b9d2406..0000000
--- a/tests/multithreading/thread_validity_11.cc
+++ /dev/null
@@ -1,50 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2008 - 2020 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE.md at
-// the top level directory of deal.II.
-//
-// ---------------------------------------------------------------------
-
-
-// It looks like we can't call std::thread::join() twice -- the second call
-// produces a std::system_error exception, and this can in fact be verified
-// because std::thread::joinable() returns false after the first call to
-// join()
-
-#include <deal.II/base/thread_management.h>
-
-#include "../tests.h"
-
-void
-execute()
-{}
-
-
-void
-test()
-{
-  Threads::Thread<> t = Threads::new_thread(&execute);
-  deallog << "Before first join()" << std::endl;
-  t.join();
-  deallog << "Between join()s" << std::endl;
-  t.join();
-  deallog << "After second join()" << std::endl;
-}
-
-
-
-int
-main()
-{
-  initlog();
-
-  test();
-}

diff --git a/tests/multithreading/thread_validity_11.output b/tests/multithreading/thread_validity_11.output
deleted file mode 100644 (file)
index 9a87789..0000000
--- a/tests/multithreading/thread_validity_11.output
+++ /dev/null
@@ -1,4 +0,0 @@
-
-DEAL::Before first join()
-DEAL::Between join()s
-DEAL::After second join()

diff --git a/tests/multithreading/thread_validity_12.cc b/tests/multithreading/thread_validity_12.cc
deleted file mode 100644 (file)
index f885f51..0000000
--- a/tests/multithreading/thread_validity_12.cc
+++ /dev/null
@@ -1,49 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2008 - 2020 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE.md at
-// the top level directory of deal.II.
-//
-// ---------------------------------------------------------------------
-
-
-// Make sure we can call Threads::Thread::join on objects that haven't even
-// been assigned a thread
-
-#include <deal.II/base/thread_management.h>
-
-#include "../tests.h"
-
-void
-execute()
-{}
-
-
-void
-test()
-{
-  // use a default constructed object
-  Threads::Thread<> t;
-  deallog << "Before first join()" << std::endl;
-  t.join();
-  deallog << "Between join()s" << std::endl;
-  t.join();
-  deallog << "After second join()" << std::endl;
-}
-
-
-
-int
-main()
-{
-  initlog();
-
-  test();
-}

diff --git a/tests/multithreading/thread_validity_12.output b/tests/multithreading/thread_validity_12.output
deleted file mode 100644 (file)
index 9a87789..0000000
--- a/tests/multithreading/thread_validity_12.output
+++ /dev/null
@@ -1,4 +0,0 @@
-
-DEAL::Before first join()
-DEAL::Between join()s
-DEAL::After second join()

diff --git a/tests/multithreading/thread_validity_13.cc b/tests/multithreading/thread_validity_13.cc
deleted file mode 100644 (file)
index 28c87d6..0000000
--- a/tests/multithreading/thread_validity_13.cc
+++ /dev/null
@@ -1,95 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2008 - 2020 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE.md at
-// the top level directory of deal.II.
-//
-// ---------------------------------------------------------------------
-
-
-// See that we can query a thread object's return value for cases
-// where these returned objects are not copyable but only
-// movable. This is relevant, for example, when calling functions that
-// return a std::unique_ptr.
-
-#include <deal.II/base/thread_management.h>
-
-#include "../tests.h"
-
-
-class X
-{
-public:
-  // default constructor
-  X()
-    : value(13)
-  {}
-
-  X(int i)
-    : value(i)
-  {}
-
-  // delete the copy constructor
-  X(const X &) = delete;
-
-  // move constructor. sets the moved-from value to a recognizable
-  // value
-  X(X &&x)
-  {
-    value   = x.value;
-    x.value = 0;
-  }
-
-  // same idea about copy operators
-  X &
-  operator=(const X &) = delete;
-
-  X &
-  operator=(X &&x)
-  {
-    value   = x.value;
-    x.value = 0;
-
-    return *this;
-  }
-
-
-  int value;
-};
-
-
-
-X
-foo()
-{
-  return X(42);
-}
-
-
-
-int
-main()
-{
-  initlog();
-
-  Threads::Thread<X> t = Threads::new_thread(&foo);
-
-  // wait for the thread to return and query its value
-  deallog << t.return_value().value << std::endl;
-
-  // we can't copy the return_value() object directly, but we can move
-  // it. do so and check that we still get the correct value. then
-  // also check that the value of the original return object has been
-  // reset in the move constructor/operator
-  X x = std::move(t.return_value());
-  deallog << x.value << std::endl;
-
-  deallog << t.return_value().value << std::endl;
-}

diff --git a/tests/multithreading/thread_validity_13.output b/tests/multithreading/thread_validity_13.output
deleted file mode 100644 (file)
index 63953b2..0000000
--- a/tests/multithreading/thread_validity_13.output
+++ /dev/null
@@ -1,4 +0,0 @@
-
-DEAL::42
-DEAL::42
-DEAL::0

diff --git a/tests/multithreading/threads_02.cc b/tests/multithreading/threads_02.cc
deleted file mode 100644 (file)
index 158420f..0000000
--- a/tests/multithreading/threads_02.cc
+++ /dev/null
@@ -1,3756 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2013 - 2021 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE.md at
-// the top level directory of deal.II.
-//
-// ---------------------------------------------------------------------
-
-#include <deal.II/base/thread_management.h>
-
-#include <iostream>
-
-#include "../tests.h"
-template <int>
-struct X
-{};
-struct U
-{
-  virtual ~U()
-  {}
-  X<0>
-  foo_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0>
-  static_foo_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &
-  static_ref_foo_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &
-  static_const_ref_foo_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_ref_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0>
-  static_foo_ref_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_ref_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_ref_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_const_ref_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_0_const() const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_ref_0_const() const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_const_ref_0_const() const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_ref_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_const_ref_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_0_const() const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_ref_0_const() const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_const_ref_0_const() const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &
-  static_ref_foo_ref_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &
-  static_const_ref_foo_ref_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_const_ref_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0>
-  static_foo_const_ref_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_const_ref_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &
-  static_ref_foo_const_ref_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &
-  static_const_ref_foo_const_ref_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_0_const() const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_0_const() const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_ref_0_const() const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_ref_0_const() const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_const_ref_0_const() const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_const_ref_0_const() const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_0_const() const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_0_const() const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_ref_0_const() const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_ref_0_const() const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_const_ref_0_const() const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_const_ref_0_const() const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_ref_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_ref_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_const_ref_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_const_ref_0()
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> foo_1(X<1>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> static_foo_1(X<1>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &ref_foo_1(X<1>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &static_ref_foo_1(X<1>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &static_const_ref_foo_1(X<1>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_ref_1(X<1> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0>
-  static_foo_ref_1(X<1> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_ref_1(X<1> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &const_ref_foo_1(X<1>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_ref_1(X<1> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_const_ref_1(X<1> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &const_ref_foo_1_const(X<1>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_ref_1_const(X<1> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_const_ref_1_const(X<1> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &virtual_const_ref_foo_1(X<1>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_ref_1(X<1> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_const_ref_1(X<1> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &virtual_const_ref_foo_1_const(X<1>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_ref_1_const(X<1> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_const_ref_1_const(X<1> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &
-  static_ref_foo_ref_1(X<1> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &
-  static_const_ref_foo_ref_1(X<1> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_const_ref_1(const X<1> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0>
-  static_foo_const_ref_1(const X<1> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_const_ref_1(const X<1> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &
-  static_ref_foo_const_ref_1(const X<1> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &
-  static_const_ref_foo_const_ref_1(const X<1> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> foo_1_const(X<1>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &ref_foo_1_const(X<1>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_ref_1_const(X<1> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_ref_1_const(X<1> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_const_ref_1_const(const X<1> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_const_ref_1_const(const X<1> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> virtual_foo_1_const(X<1>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &virtual_ref_foo_1_const(X<1>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_ref_1_const(X<1> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_ref_1_const(X<1> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_const_ref_1_const(const X<1> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_const_ref_1_const(const X<1> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> virtual_foo_1(X<1>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &virtual_ref_foo_1(X<1>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_ref_1(X<1> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_ref_1(X<1> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_const_ref_1(const X<1> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_const_ref_1(const X<1> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> foo_2(X<1>, X<2>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> static_foo_2(X<1>, X<2>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &ref_foo_2(X<1>, X<2>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &static_ref_foo_2(X<1>, X<2>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &static_const_ref_foo_2(X<1>, X<2>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_ref_2(X<1> &, X<2> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0>
-  static_foo_ref_2(X<1> &, X<2> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_ref_2(X<1> &, X<2> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &const_ref_foo_2(X<1>, X<2>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_ref_2(X<1> &, X<2> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_const_ref_2(X<1> &, X<2> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &const_ref_foo_2_const(X<1>, X<2>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_ref_2_const(X<1> &, X<2> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_const_ref_2_const(X<1> &, X<2> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &virtual_const_ref_foo_2(X<1>, X<2>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_ref_2(X<1> &, X<2> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_const_ref_2(X<1> &, X<2> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &virtual_const_ref_foo_2_const(X<1>, X<2>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_ref_2_const(X<1> &, X<2> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_const_ref_2_const(X<1> &, X<2> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &
-  static_ref_foo_ref_2(X<1> &, X<2> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &
-  static_const_ref_foo_ref_2(X<1> &, X<2> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_const_ref_2(const X<1> &, const X<2> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0>
-  static_foo_const_ref_2(const X<1> &, const X<2> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_const_ref_2(const X<1> &, const X<2> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &
-  static_ref_foo_const_ref_2(const X<1> &, const X<2> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &
-  static_const_ref_foo_const_ref_2(const X<1> &, const X<2> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> foo_2_const(X<1>, X<2>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &ref_foo_2_const(X<1>, X<2>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_ref_2_const(X<1> &, X<2> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_ref_2_const(X<1> &, X<2> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_const_ref_2_const(const X<1> &, const X<2> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_const_ref_2_const(const X<1> &, const X<2> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> virtual_foo_2_const(X<1>, X<2>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &virtual_ref_foo_2_const(X<1>, X<2>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_ref_2_const(X<1> &, X<2> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_ref_2_const(X<1> &, X<2> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_const_ref_2_const(const X<1> &, const X<2> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_const_ref_2_const(const X<1> &, const X<2> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> virtual_foo_2(X<1>, X<2>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &virtual_ref_foo_2(X<1>, X<2>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_ref_2(X<1> &, X<2> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_ref_2(X<1> &, X<2> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_const_ref_2(const X<1> &, const X<2> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_const_ref_2(const X<1> &, const X<2> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> foo_3(X<1>, X<2>, X<3>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> static_foo_3(X<1>, X<2>, X<3>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &ref_foo_3(X<1>, X<2>, X<3>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &static_ref_foo_3(X<1>, X<2>, X<3>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &static_const_ref_foo_3(X<1>, X<2>, X<3>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_ref_3(X<1> &, X<2> &, X<3> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0>
-  static_foo_ref_3(X<1> &, X<2> &, X<3> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_ref_3(X<1> &, X<2> &, X<3> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &const_ref_foo_3(X<1>, X<2>, X<3>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_ref_3(X<1> &, X<2> &, X<3> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_const_ref_3(X<1> &, X<2> &, X<3> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &const_ref_foo_3_const(X<1>, X<2>, X<3>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_ref_3_const(X<1> &, X<2> &, X<3> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_const_ref_3_const(X<1> &, X<2> &, X<3> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &virtual_const_ref_foo_3(X<1>, X<2>, X<3>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_ref_3(X<1> &, X<2> &, X<3> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_const_ref_3(X<1> &, X<2> &, X<3> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &virtual_const_ref_foo_3_const(X<1>, X<2>, X<3>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_ref_3_const(X<1> &, X<2> &, X<3> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_const_ref_3_const(X<1> &, X<2> &, X<3> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &
-  static_ref_foo_ref_3(X<1> &, X<2> &, X<3> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &
-  static_const_ref_foo_ref_3(X<1> &, X<2> &, X<3> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_const_ref_3(const X<1> &, const X<2> &, const X<3> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0>
-  static_foo_const_ref_3(const X<1> &, const X<2> &, const X<3> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_const_ref_3(const X<1> &, const X<2> &, const X<3> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &
-  static_ref_foo_const_ref_3(const X<1> &, const X<2> &, const X<3> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &
-  static_const_ref_foo_const_ref_3(const X<1> &, const X<2> &, const X<3> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> foo_3_const(X<1>, X<2>, X<3>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &ref_foo_3_const(X<1>, X<2>, X<3>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_ref_3_const(X<1> &, X<2> &, X<3> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_ref_3_const(X<1> &, X<2> &, X<3> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_const_ref_3_const(const X<1> &, const X<2> &, const X<3> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_const_ref_3_const(const X<1> &, const X<2> &, const X<3> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> virtual_foo_3_const(X<1>, X<2>, X<3>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &virtual_ref_foo_3_const(X<1>, X<2>, X<3>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_ref_3_const(X<1> &, X<2> &, X<3> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_ref_3_const(X<1> &, X<2> &, X<3> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_const_ref_3_const(const X<1> &, const X<2> &, const X<3> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_const_ref_3_const(const X<1> &,
-                                    const X<2> &,
-                                    const X<3> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> virtual_foo_3(X<1>, X<2>, X<3>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &virtual_ref_foo_3(X<1>, X<2>, X<3>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_ref_3(X<1> &, X<2> &, X<3> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_ref_3(X<1> &, X<2> &, X<3> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_const_ref_3(const X<1> &, const X<2> &, const X<3> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_const_ref_3(const X<1> &, const X<2> &, const X<3> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> foo_4(X<1>, X<2>, X<3>, X<4>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> static_foo_4(X<1>, X<2>, X<3>, X<4>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &ref_foo_4(X<1>, X<2>, X<3>, X<4>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &static_ref_foo_4(X<1>, X<2>, X<3>, X<4>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &static_const_ref_foo_4(X<1>, X<2>, X<3>, X<4>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0>
-  static_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &const_ref_foo_4(X<1>, X<2>, X<3>, X<4>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_const_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &const_ref_foo_4_const(X<1>, X<2>, X<3>, X<4>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_const_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &virtual_const_ref_foo_4(X<1>, X<2>, X<3>, X<4>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_const_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-    virtual_const_ref_foo_4_const(X<1>, X<2>, X<3>, X<4>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_const_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &
-  static_ref_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &
-  static_const_ref_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_const_ref_4(const X<1> &, const X<2> &, const X<3> &, const X<4> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0>
-  static_foo_const_ref_4(const X<1> &, const X<2> &, const X<3> &, const X<4> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_const_ref_4(const X<1> &, const X<2> &, const X<3> &, const X<4> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &
-  static_ref_foo_const_ref_4(const X<1> &,
-                             const X<2> &,
-                             const X<3> &,
-                             const X<4> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &
-  static_const_ref_foo_const_ref_4(const X<1> &,
-                                   const X<2> &,
-                                   const X<3> &,
-                                   const X<4> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> foo_4_const(X<1>, X<2>, X<3>, X<4>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &ref_foo_4_const(X<1>, X<2>, X<3>, X<4>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_const_ref_4_const(const X<1> &,
-                        const X<2> &,
-                        const X<3> &,
-                        const X<4> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_const_ref_4_const(const X<1> &,
-                            const X<2> &,
-                            const X<3> &,
-                            const X<4> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> virtual_foo_4_const(X<1>, X<2>, X<3>, X<4>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &virtual_ref_foo_4_const(X<1>, X<2>, X<3>, X<4>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_ref_4_const(X<1> &, X<2> &, X<3> &, X<4> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_const_ref_4_const(const X<1> &,
-                                const X<2> &,
-                                const X<3> &,
-                                const X<4> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_const_ref_4_const(const X<1> &,
-                                    const X<2> &,
-                                    const X<3> &,
-                                    const X<4> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> virtual_foo_4(X<1>, X<2>, X<3>, X<4>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &virtual_ref_foo_4(X<1>, X<2>, X<3>, X<4>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_ref_4(X<1> &, X<2> &, X<3> &, X<4> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_const_ref_4(const X<1> &,
-                          const X<2> &,
-                          const X<3> &,
-                          const X<4> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_const_ref_4(const X<1> &,
-                              const X<2> &,
-                              const X<3> &,
-                              const X<4> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> foo_5(X<1>, X<2>, X<3>, X<4>, X<5>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> static_foo_5(X<1>, X<2>, X<3>, X<4>, X<5>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &ref_foo_5(X<1>, X<2>, X<3>, X<4>, X<5>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &static_ref_foo_5(X<1>, X<2>, X<3>, X<4>, X<5>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &static_const_ref_foo_5(X<1>, X<2>, X<3>, X<4>, X<5>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0>
-  static_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &const_ref_foo_5(X<1>, X<2>, X<3>, X<4>, X<5>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_const_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &const_ref_foo_5_const(X<1>, X<2>, X<3>, X<4>, X<5>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_ref_5_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_const_ref_5_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &virtual_const_ref_foo_5(X<1>, X<2>, X<3>, X<4>, X<5>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_const_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-    virtual_const_ref_foo_5_const(X<1>, X<2>, X<3>, X<4>, X<5>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_ref_5_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
-    const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_const_ref_5_const(X<1> &,
-                                          X<2> &,
-                                          X<3> &,
-                                          X<4> &,
-                                          X<5> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &
-  static_ref_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &
-  static_const_ref_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_const_ref_5(const X<1> &,
-                  const X<2> &,
-                  const X<3> &,
-                  const X<4> &,
-                  const X<5> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0>
-  static_foo_const_ref_5(const X<1> &,
-                         const X<2> &,
-                         const X<3> &,
-                         const X<4> &,
-                         const X<5> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_const_ref_5(const X<1> &,
-                      const X<2> &,
-                      const X<3> &,
-                      const X<4> &,
-                      const X<5> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &
-  static_ref_foo_const_ref_5(const X<1> &,
-                             const X<2> &,
-                             const X<3> &,
-                             const X<4> &,
-                             const X<5> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &
-  static_const_ref_foo_const_ref_5(const X<1> &,
-                                   const X<2> &,
-                                   const X<3> &,
-                                   const X<4> &,
-                                   const X<5> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> foo_5_const(X<1>, X<2>, X<3>, X<4>, X<5>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &ref_foo_5_const(X<1>, X<2>, X<3>, X<4>, X<5>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_ref_5_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_ref_5_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_const_ref_5_const(const X<1> &,
-                        const X<2> &,
-                        const X<3> &,
-                        const X<4> &,
-                        const X<5> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_const_ref_5_const(const X<1> &,
-                            const X<2> &,
-                            const X<3> &,
-                            const X<4> &,
-                            const X<5> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> virtual_foo_5_const(X<1>, X<2>, X<3>, X<4>, X<5>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &virtual_ref_foo_5_const(X<1>, X<2>, X<3>, X<4>, X<5>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_ref_5_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_ref_5_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_const_ref_5_const(const X<1> &,
-                                const X<2> &,
-                                const X<3> &,
-                                const X<4> &,
-                                const X<5> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_const_ref_5_const(const X<1> &,
-                                    const X<2> &,
-                                    const X<3> &,
-                                    const X<4> &,
-                                    const X<5> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> virtual_foo_5(X<1>, X<2>, X<3>, X<4>, X<5>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &virtual_ref_foo_5(X<1>, X<2>, X<3>, X<4>, X<5>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_ref_5(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_const_ref_5(const X<1> &,
-                          const X<2> &,
-                          const X<3> &,
-                          const X<4> &,
-                          const X<5> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_const_ref_5(const X<1> &,
-                              const X<2> &,
-                              const X<3> &,
-                              const X<4> &,
-                              const X<5> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> foo_6(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> static_foo_6(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &ref_foo_6(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &static_ref_foo_6(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &static_const_ref_foo_6(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0>
-  static_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &const_ref_foo_6(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_const_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &const_ref_foo_6_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_ref_6_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
-    const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_const_ref_6_const(X<1> &,
-                                  X<2> &,
-                                  X<3> &,
-                                  X<4> &,
-                                  X<5> &,
-                                  X<6> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-    virtual_const_ref_foo_6(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_const_ref_6(X<1> &,
-                                    X<2> &,
-                                    X<3> &,
-                                    X<4> &,
-                                    X<5> &,
-                                    X<6> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-    virtual_const_ref_foo_6_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_ref_6_const(X<1> &,
-                                    X<2> &,
-                                    X<3> &,
-                                    X<4> &,
-                                    X<5> &,
-                                    X<6> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_const_ref_6_const(X<1> &,
-                                          X<2> &,
-                                          X<3> &,
-                                          X<4> &,
-                                          X<5> &,
-                                          X<6> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &
-  static_ref_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &
-  static_const_ref_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_const_ref_6(const X<1> &,
-                  const X<2> &,
-                  const X<3> &,
-                  const X<4> &,
-                  const X<5> &,
-                  const X<6> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0>
-  static_foo_const_ref_6(const X<1> &,
-                         const X<2> &,
-                         const X<3> &,
-                         const X<4> &,
-                         const X<5> &,
-                         const X<6> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_const_ref_6(const X<1> &,
-                      const X<2> &,
-                      const X<3> &,
-                      const X<4> &,
-                      const X<5> &,
-                      const X<6> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &
-  static_ref_foo_const_ref_6(const X<1> &,
-                             const X<2> &,
-                             const X<3> &,
-                             const X<4> &,
-                             const X<5> &,
-                             const X<6> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &
-  static_const_ref_foo_const_ref_6(const X<1> &,
-                                   const X<2> &,
-                                   const X<3> &,
-                                   const X<4> &,
-                                   const X<5> &,
-                                   const X<6> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> foo_6_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &ref_foo_6_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_ref_6_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_ref_6_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_const_ref_6_const(const X<1> &,
-                        const X<2> &,
-                        const X<3> &,
-                        const X<4> &,
-                        const X<5> &,
-                        const X<6> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_const_ref_6_const(const X<1> &,
-                            const X<2> &,
-                            const X<3> &,
-                            const X<4> &,
-                            const X<5> &,
-                            const X<6> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> virtual_foo_6_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-    virtual_ref_foo_6_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_ref_6_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_ref_6_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
-    const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_const_ref_6_const(const X<1> &,
-                                const X<2> &,
-                                const X<3> &,
-                                const X<4> &,
-                                const X<5> &,
-                                const X<6> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_const_ref_6_const(const X<1> &,
-                                    const X<2> &,
-                                    const X<3> &,
-                                    const X<4> &,
-                                    const X<5> &,
-                                    const X<6> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> virtual_foo_6(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &virtual_ref_foo_6(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_ref_6(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_const_ref_6(const X<1> &,
-                          const X<2> &,
-                          const X<3> &,
-                          const X<4> &,
-                          const X<5> &,
-                          const X<6> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_const_ref_6(const X<1> &,
-                              const X<2> &,
-                              const X<3> &,
-                              const X<4> &,
-                              const X<5> &,
-                              const X<6> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> foo_7(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> static_foo_7(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &ref_foo_7(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &static_ref_foo_7(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &
-    static_const_ref_foo_7(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_ref_7(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0>
-  static_foo_ref_7(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_ref_7(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &const_ref_foo_7(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_ref_7(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_const_ref_7(X<1> &,
-                            X<2> &,
-                            X<3> &,
-                            X<4> &,
-                            X<5> &,
-                            X<6> &,
-                            X<7> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-    const_ref_foo_7_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_ref_7_const(X<1> &,
-                            X<2> &,
-                            X<3> &,
-                            X<4> &,
-                            X<5> &,
-                            X<6> &,
-                            X<7> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_const_ref_7_const(X<1> &,
-                                  X<2> &,
-                                  X<3> &,
-                                  X<4> &,
-                                  X<5> &,
-                                  X<6> &,
-                                  X<7> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-    virtual_const_ref_foo_7(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_ref_7(X<1> &,
-                              X<2> &,
-                              X<3> &,
-                              X<4> &,
-                              X<5> &,
-                              X<6> &,
-                              X<7> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_const_ref_7(X<1> &,
-                                    X<2> &,
-                                    X<3> &,
-                                    X<4> &,
-                                    X<5> &,
-                                    X<6> &,
-                                    X<7> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &virtual_const_ref_foo_7_const(X<1>,
-                                                    X<2>,
-                                                    X<3>,
-                                                    X<4>,
-                                                    X<5>,
-                                                    X<6>,
-                                                    X<7>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_ref_7_const(X<1> &,
-                                    X<2> &,
-                                    X<3> &,
-                                    X<4> &,
-                                    X<5> &,
-                                    X<6> &,
-                                    X<7> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_const_ref_7_const(X<1> &,
-                                          X<2> &,
-                                          X<3> &,
-                                          X<4> &,
-                                          X<5> &,
-                                          X<6> &,
-                                          X<7> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &
-  static_ref_foo_ref_7(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &
-  static_const_ref_foo_ref_7(X<1> &,
-                             X<2> &,
-                             X<3> &,
-                             X<4> &,
-                             X<5> &,
-                             X<6> &,
-                             X<7> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_const_ref_7(const X<1> &,
-                  const X<2> &,
-                  const X<3> &,
-                  const X<4> &,
-                  const X<5> &,
-                  const X<6> &,
-                  const X<7> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0>
-  static_foo_const_ref_7(const X<1> &,
-                         const X<2> &,
-                         const X<3> &,
-                         const X<4> &,
-                         const X<5> &,
-                         const X<6> &,
-                         const X<7> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_const_ref_7(const X<1> &,
-                      const X<2> &,
-                      const X<3> &,
-                      const X<4> &,
-                      const X<5> &,
-                      const X<6> &,
-                      const X<7> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &
-  static_ref_foo_const_ref_7(const X<1> &,
-                             const X<2> &,
-                             const X<3> &,
-                             const X<4> &,
-                             const X<5> &,
-                             const X<6> &,
-                             const X<7> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &
-  static_const_ref_foo_const_ref_7(const X<1> &,
-                                   const X<2> &,
-                                   const X<3> &,
-                                   const X<4> &,
-                                   const X<5> &,
-                                   const X<6> &,
-                                   const X<7> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> foo_7_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &ref_foo_7_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_ref_7_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_ref_7_const(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
-    const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_const_ref_7_const(const X<1> &,
-                        const X<2> &,
-                        const X<3> &,
-                        const X<4> &,
-                        const X<5> &,
-                        const X<6> &,
-                        const X<7> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_const_ref_7_const(const X<1> &,
-                            const X<2> &,
-                            const X<3> &,
-                            const X<4> &,
-                            const X<5> &,
-                            const X<6> &,
-                            const X<7> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-    virtual_foo_7_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-    virtual_ref_foo_7_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_ref_7_const(X<1> &,
-                          X<2> &,
-                          X<3> &,
-                          X<4> &,
-                          X<5> &,
-                          X<6> &,
-                          X<7> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_ref_7_const(X<1> &,
-                              X<2> &,
-                              X<3> &,
-                              X<4> &,
-                              X<5> &,
-                              X<6> &,
-                              X<7> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_const_ref_7_const(const X<1> &,
-                                const X<2> &,
-                                const X<3> &,
-                                const X<4> &,
-                                const X<5> &,
-                                const X<6> &,
-                                const X<7> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_const_ref_7_const(const X<1> &,
-                                    const X<2> &,
-                                    const X<3> &,
-                                    const X<4> &,
-                                    const X<5> &,
-                                    const X<6> &,
-                                    const X<7> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> virtual_foo_7(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &virtual_ref_foo_7(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_ref_7(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_ref_7(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_const_ref_7(const X<1> &,
-                          const X<2> &,
-                          const X<3> &,
-                          const X<4> &,
-                          const X<5> &,
-                          const X<6> &,
-                          const X<7> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_const_ref_7(const X<1> &,
-                              const X<2> &,
-                              const X<3> &,
-                              const X<4> &,
-                              const X<5> &,
-                              const X<6> &,
-                              const X<7> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> foo_8(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> static_foo_8(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &ref_foo_8(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &static_ref_foo_8(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &
-    static_const_ref_foo_8(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_ref_8(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &, X<8> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0>
-  static_foo_ref_8(X<1> &,
-                   X<2> &,
-                   X<3> &,
-                   X<4> &,
-                   X<5> &,
-                   X<6> &,
-                   X<7> &,
-                   X<8> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_ref_8(X<1> &, X<2> &, X<3> &, X<4> &, X<5> &, X<6> &, X<7> &, X<8> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &const_ref_foo_8(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_ref_8(X<1> &,
-                      X<2> &,
-                      X<3> &,
-                      X<4> &,
-                      X<5> &,
-                      X<6> &,
-                      X<7> &,
-                      X<8> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_const_ref_8(X<1> &,
-                            X<2> &,
-                            X<3> &,
-                            X<4> &,
-                            X<5> &,
-                            X<6> &,
-                            X<7> &,
-                            X<8> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-    const_ref_foo_8_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_ref_8_const(X<1> &,
-                            X<2> &,
-                            X<3> &,
-                            X<4> &,
-                            X<5> &,
-                            X<6> &,
-                            X<7> &,
-                            X<8> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  const X<0> &
-  const_ref_foo_const_ref_8_const(X<1> &,
-                                  X<2> &,
-                                  X<3> &,
-                                  X<4> &,
-                                  X<5> &,
-                                  X<6> &,
-                                  X<7> &,
-                                  X<8> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-    virtual_const_ref_foo_8(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_ref_8(X<1> &,
-                              X<2> &,
-                              X<3> &,
-                              X<4> &,
-                              X<5> &,
-                              X<6> &,
-                              X<7> &,
-                              X<8> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_const_ref_8(X<1> &,
-                                    X<2> &,
-                                    X<3> &,
-                                    X<4> &,
-                                    X<5> &,
-                                    X<6> &,
-                                    X<7> &,
-                                    X<8> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &virtual_const_ref_foo_8_const(X<1>,
-                                                    X<2>,
-                                                    X<3>,
-                                                    X<4>,
-                                                    X<5>,
-                                                    X<6>,
-                                                    X<7>,
-                                                    X<8>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_ref_8_const(X<1> &,
-                                    X<2> &,
-                                    X<3> &,
-                                    X<4> &,
-                                    X<5> &,
-                                    X<6> &,
-                                    X<7> &,
-                                    X<8> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual const X<0> &
-  virtual_const_ref_foo_const_ref_8_const(X<1> &,
-                                          X<2> &,
-                                          X<3> &,
-                                          X<4> &,
-                                          X<5> &,
-                                          X<6> &,
-                                          X<7> &,
-                                          X<8> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &
-  static_ref_foo_ref_8(X<1> &,
-                       X<2> &,
-                       X<3> &,
-                       X<4> &,
-                       X<5> &,
-                       X<6> &,
-                       X<7> &,
-                       X<8> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &
-  static_const_ref_foo_ref_8(X<1> &,
-                             X<2> &,
-                             X<3> &,
-                             X<4> &,
-                             X<5> &,
-                             X<6> &,
-                             X<7> &,
-                             X<8> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_const_ref_8(const X<1> &,
-                  const X<2> &,
-                  const X<3> &,
-                  const X<4> &,
-                  const X<5> &,
-                  const X<6> &,
-                  const X<7> &,
-                  const X<8> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0>
-  static_foo_const_ref_8(const X<1> &,
-                         const X<2> &,
-                         const X<3> &,
-                         const X<4> &,
-                         const X<5> &,
-                         const X<6> &,
-                         const X<7> &,
-                         const X<8> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_const_ref_8(const X<1> &,
-                      const X<2> &,
-                      const X<3> &,
-                      const X<4> &,
-                      const X<5> &,
-                      const X<6> &,
-                      const X<7> &,
-                      const X<8> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static X<0> &
-  static_ref_foo_const_ref_8(const X<1> &,
-                             const X<2> &,
-                             const X<3> &,
-                             const X<4> &,
-                             const X<5> &,
-                             const X<6> &,
-                             const X<7> &,
-                             const X<8> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  static const X<0> &
-  static_const_ref_foo_const_ref_8(const X<1> &,
-                                   const X<2> &,
-                                   const X<3> &,
-                                   const X<4> &,
-                                   const X<5> &,
-                                   const X<6> &,
-                                   const X<7> &,
-                                   const X<8> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> foo_8_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &ref_foo_8_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_ref_8_const(X<1> &,
-                  X<2> &,
-                  X<3> &,
-                  X<4> &,
-                  X<5> &,
-                  X<6> &,
-                  X<7> &,
-                  X<8> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_ref_8_const(X<1> &,
-                      X<2> &,
-                      X<3> &,
-                      X<4> &,
-                      X<5> &,
-                      X<6> &,
-                      X<7> &,
-                      X<8> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0>
-  foo_const_ref_8_const(const X<1> &,
-                        const X<2> &,
-                        const X<3> &,
-                        const X<4> &,
-                        const X<5> &,
-                        const X<6> &,
-                        const X<7> &,
-                        const X<8> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  X<0> &
-  ref_foo_const_ref_8_const(const X<1> &,
-                            const X<2> &,
-                            const X<3> &,
-                            const X<4> &,
-                            const X<5> &,
-                            const X<6> &,
-                            const X<7> &,
-                            const X<8> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-    virtual_foo_8_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-    virtual_ref_foo_8_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>)
-      const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_ref_8_const(X<1> &,
-                          X<2> &,
-                          X<3> &,
-                          X<4> &,
-                          X<5> &,
-                          X<6> &,
-                          X<7> &,
-                          X<8> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_ref_8_const(X<1> &,
-                              X<2> &,
-                              X<3> &,
-                              X<4> &,
-                              X<5> &,
-                              X<6> &,
-                              X<7> &,
-                              X<8> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_const_ref_8_const(const X<1> &,
-                                const X<2> &,
-                                const X<3> &,
-                                const X<4> &,
-                                const X<5> &,
-                                const X<6> &,
-                                const X<7> &,
-                                const X<8> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_const_ref_8_const(const X<1> &,
-                                    const X<2> &,
-                                    const X<3> &,
-                                    const X<4> &,
-                                    const X<5> &,
-                                    const X<6> &,
-                                    const X<7> &,
-                                    const X<8> &) const
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> virtual_foo_8(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-    virtual_ref_foo_8(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_ref_8(X<1> &,
-                    X<2> &,
-                    X<3> &,
-                    X<4> &,
-                    X<5> &,
-                    X<6> &,
-                    X<7> &,
-                    X<8> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_ref_8(X<1> &,
-                        X<2> &,
-                        X<3> &,
-                        X<4> &,
-                        X<5> &,
-                        X<6> &,
-                        X<7> &,
-                        X<8> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0>
-  virtual_foo_const_ref_8(const X<1> &,
-                          const X<2> &,
-                          const X<3> &,
-                          const X<4> &,
-                          const X<5> &,
-                          const X<6> &,
-                          const X<7> &,
-                          const X<8> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-  virtual X<0> &
-  virtual_ref_foo_const_ref_8(const X<1> &,
-                              const X<2> &,
-                              const X<3> &,
-                              const X<4> &,
-                              const X<5> &,
-                              const X<6> &,
-                              const X<7> &,
-                              const X<8> &)
-  {
-    deallog << unify_pretty_function(__PRETTY_FUNCTION__) << std::endl;
-    static X<0> x;
-    return x;
-  }
-};
-int
-main()
-{
-  initlog();
-
-  using namespace Threads;
-  ThreadGroup<X<0>>         tg;
-  ThreadGroup<X<0> &>       tgr;
-  ThreadGroup<const X<0> &> tgcr;
-  U                         u;
-  X<1>                      x1;
-  X<2>                      x2;
-  X<3>                      x3;
-  X<4>                      x4;
-  X<5>                      x5;
-  X<6>                      x6;
-  X<7>                      x7;
-  X<8>                      x8;
-  tgr += new_thread(&U::ref_foo_0, u);
-  tgr += new_thread(&U::ref_foo_0_const, u);
-  tgr += new_thread(&U::ref_foo_const_ref_0, u);
-  tgr += new_thread(&U::ref_foo_const_ref_0_const, u);
-  tgr += new_thread(&U::ref_foo_ref_0, u);
-  tgr += new_thread(&U::ref_foo_ref_0_const, u);
-  tgcr += new_thread(&U::const_ref_foo_0, u);
-  tgcr += new_thread(&U::const_ref_foo_0_const, u);
-  tgcr += new_thread(&U::const_ref_foo_const_ref_0, u);
-  tgcr += new_thread(&U::const_ref_foo_const_ref_0_const, u);
-  tgcr += new_thread(&U::const_ref_foo_ref_0, u);
-  tgcr += new_thread(&U::const_ref_foo_ref_0_const, u);
-  tgcr += new_thread(&U::virtual_const_ref_foo_0, u);
-  tgcr += new_thread(&U::virtual_const_ref_foo_0_const, u);
-  tgcr += new_thread(&U::virtual_const_ref_foo_const_ref_0, u);
-  tgcr += new_thread(&U::virtual_const_ref_foo_const_ref_0_const, u);
-  tgcr += new_thread(&U::virtual_const_ref_foo_ref_0, u);
-  tgcr += new_thread(&U::virtual_const_ref_foo_ref_0_const, u);
-  tg += new_thread(&U::foo_0, u);
-  tg += new_thread(&U::foo_0_const, u);
-  tg += new_thread(&U::foo_const_ref_0, u);
-  tg += new_thread(&U::foo_const_ref_0_const, u);
-  tg += new_thread(&U::foo_ref_0, u);
-  tg += new_thread(&U::foo_ref_0_const, u);
-  tgr += new_thread(&U::virtual_ref_foo_0, u);
-  tgr += new_thread(&U::virtual_ref_foo_0_const, u);
-  tgr += new_thread(&U::virtual_ref_foo_const_ref_0, u);
-  tgr += new_thread(&U::virtual_ref_foo_const_ref_0_const, u);
-  tgr += new_thread(&U::virtual_ref_foo_ref_0, u);
-  tgr += new_thread(&U::virtual_ref_foo_ref_0_const, u);
-  tg += new_thread(&U::virtual_foo_0, u);
-  tg += new_thread(&U::virtual_foo_0_const, u);
-  tg += new_thread(&U::virtual_foo_const_ref_0, u);
-  tg += new_thread(&U::virtual_foo_const_ref_0_const, u);
-  tg += new_thread(&U::virtual_foo_ref_0, u);
-  tg += new_thread(&U::virtual_foo_ref_0_const, u);
-
-  tgr += new_thread(&U::static_ref_foo_0);
-  tgr += new_thread(&U::static_ref_foo_const_ref_0);
-  tgr += new_thread(&U::static_ref_foo_ref_0);
-  tgcr += new_thread(&U::static_const_ref_foo_0);
-  tgcr += new_thread(&U::static_const_ref_foo_const_ref_0);
-  tgcr += new_thread(&U::static_const_ref_foo_ref_0);
-  tg += new_thread(&U::static_foo_0);
-  tg += new_thread(&U::static_foo_const_ref_0);
-  tg += new_thread(&U::static_foo_ref_0);
-  tgr += new_thread(&U::ref_foo_1, u, x1);
-  tgr += new_thread(&U::ref_foo_1_const, u, x1);
-  tgr += new_thread(&U::ref_foo_const_ref_1, u, x1);
-  tgr += new_thread(&U::ref_foo_const_ref_1_const, u, x1);
-  tgr += new_thread(&U::ref_foo_ref_1, u, x1);
-  tgr += new_thread(&U::ref_foo_ref_1_const, u, x1);
-  tgcr += new_thread(&U::const_ref_foo_1, u, x1);
-  tgcr += new_thread(&U::const_ref_foo_1_const, u, x1);
-  tgcr += new_thread(&U::const_ref_foo_const_ref_1, u, x1);
-  tgcr += new_thread(&U::const_ref_foo_const_ref_1_const, u, x1);
-  tgcr += new_thread(&U::const_ref_foo_ref_1, u, x1);
-  tgcr += new_thread(&U::const_ref_foo_ref_1_const, u, x1);
-  tgcr += new_thread(&U::virtual_const_ref_foo_1, u, x1);
-  tgcr += new_thread(&U::virtual_const_ref_foo_1_const, u, x1);
-  tgcr += new_thread(&U::virtual_const_ref_foo_const_ref_1, u, x1);
-  tgcr += new_thread(&U::virtual_const_ref_foo_const_ref_1_const, u, x1);
-  tgcr += new_thread(&U::virtual_const_ref_foo_ref_1, u, x1);
-  tgcr += new_thread(&U::virtual_const_ref_foo_ref_1_const, u, x1);
-  tg += new_thread(&U::foo_1, u, x1);
-  tg += new_thread(&U::foo_1_const, u, x1);
-  tg += new_thread(&U::foo_const_ref_1, u, x1);
-  tg += new_thread(&U::foo_const_ref_1_const, u, x1);
-  tg += new_thread(&U::foo_ref_1, u, x1);
-  tg += new_thread(&U::foo_ref_1_const, u, x1);
-  tgr += new_thread(&U::virtual_ref_foo_1, u, x1);
-  tgr += new_thread(&U::virtual_ref_foo_1_const, u, x1);
-  tgr += new_thread(&U::virtual_ref_foo_const_ref_1, u, x1);
-  tgr += new_thread(&U::virtual_ref_foo_const_ref_1_const, u, x1);
-  tgr += new_thread(&U::virtual_ref_foo_ref_1, u, x1);
-  tgr += new_thread(&U::virtual_ref_foo_ref_1_const, u, x1);
-  tg += new_thread(&U::virtual_foo_1, u, x1);
-  tg += new_thread(&U::virtual_foo_1_const, u, x1);
-  tg += new_thread(&U::virtual_foo_const_ref_1, u, x1);
-  tg += new_thread(&U::virtual_foo_const_ref_1_const, u, x1);
-  tg += new_thread(&U::virtual_foo_ref_1, u, x1);
-  tg += new_thread(&U::virtual_foo_ref_1_const, u, x1);
-
-  tgr += new_thread(&U::static_ref_foo_1, x1);
-  tgr += new_thread(&U::static_ref_foo_const_ref_1, x1);
-  tgr += new_thread(&U::static_ref_foo_ref_1, x1);
-  tgcr += new_thread(&U::static_const_ref_foo_1, x1);
-  tgcr += new_thread(&U::static_const_ref_foo_const_ref_1, x1);
-  tgcr += new_thread(&U::static_const_ref_foo_ref_1, x1);
-  tg += new_thread(&U::static_foo_1, x1);
-  tg += new_thread(&U::static_foo_const_ref_1, x1);
-  tg += new_thread(&U::static_foo_ref_1, x1);
-  tgr += new_thread(&U::ref_foo_2, u, x1, x2);
-  tgr += new_thread(&U::ref_foo_2_const, u, x1, x2);
-  tgr += new_thread(&U::ref_foo_const_ref_2, u, x1, x2);
-  tgr += new_thread(&U::ref_foo_const_ref_2_const, u, x1, x2);
-  tgr += new_thread(&U::ref_foo_ref_2, u, x1, x2);
-  tgr += new_thread(&U::ref_foo_ref_2_const, u, x1, x2);
-  tgcr += new_thread(&U::const_ref_foo_2, u, x1, x2);
-  tgcr += new_thread(&U::const_ref_foo_2_const, u, x1, x2);
-  tgcr += new_thread(&U::const_ref_foo_const_ref_2, u, x1, x2);
-  tgcr += new_thread(&U::const_ref_foo_const_ref_2_const, u, x1, x2);
-  tgcr += new_thread(&U::const_ref_foo_ref_2, u, x1, x2);
-  tgcr += new_thread(&U::const_ref_foo_ref_2_const, u, x1, x2);
-  tgcr += new_thread(&U::virtual_const_ref_foo_2, u, x1, x2);
-  tgcr += new_thread(&U::virtual_const_ref_foo_2_const, u, x1, x2);
-  tgcr += new_thread(&U::virtual_const_ref_foo_const_ref_2, u, x1, x2);
-  tgcr += new_thread(&U::virtual_const_ref_foo_const_ref_2_const, u, x1, x2);
-  tgcr += new_thread(&U::virtual_const_ref_foo_ref_2, u, x1, x2);
-  tgcr += new_thread(&U::virtual_const_ref_foo_ref_2_const, u, x1, x2);
-  tg += new_thread(&U::foo_2, u, x1, x2);
-  tg += new_thread(&U::foo_2_const, u, x1, x2);
-  tg += new_thread(&U::foo_const_ref_2, u, x1, x2);
-  tg += new_thread(&U::foo_const_ref_2_const, u, x1, x2);
-  tg += new_thread(&U::foo_ref_2, u, x1, x2);
-  tg += new_thread(&U::foo_ref_2_const, u, x1, x2);
-  tgr += new_thread(&U::virtual_ref_foo_2, u, x1, x2);
-  tgr += new_thread(&U::virtual_ref_foo_2_const, u, x1, x2);
-  tgr += new_thread(&U::virtual_ref_foo_const_ref_2, u, x1, x2);
-  tgr += new_thread(&U::virtual_ref_foo_const_ref_2_const, u, x1, x2);
-  tgr += new_thread(&U::virtual_ref_foo_ref_2, u, x1, x2);
-  tgr += new_thread(&U::virtual_ref_foo_ref_2_const, u, x1, x2);
-  tg += new_thread(&U::virtual_foo_2, u, x1, x2);
-  tg += new_thread(&U::virtual_foo_2_const, u, x1, x2);
-  tg += new_thread(&U::virtual_foo_const_ref_2, u, x1, x2);
-  tg += new_thread(&U::virtual_foo_const_ref_2_const, u, x1, x2);
-  tg += new_thread(&U::virtual_foo_ref_2, u, x1, x2);
-  tg += new_thread(&U::virtual_foo_ref_2_const, u, x1, x2);
-
-  tgr += new_thread(&U::static_ref_foo_2, x1, x2);
-  tgr += new_thread(&U::static_ref_foo_const_ref_2, x1, x2);
-  tgr += new_thread(&U::static_ref_foo_ref_2, x1, x2);
-  tgcr += new_thread(&U::static_const_ref_foo_2, x1, x2);
-  tgcr += new_thread(&U::static_const_ref_foo_const_ref_2, x1, x2);
-  tgcr += new_thread(&U::static_const_ref_foo_ref_2, x1, x2);
-  tg += new_thread(&U::static_foo_2, x1, x2);
-  tg += new_thread(&U::static_foo_const_ref_2, x1, x2);
-  tg += new_thread(&U::static_foo_ref_2, x1, x2);
-  tgr += new_thread(&U::ref_foo_3, u, x1, x2, x3);
-  tgr += new_thread(&U::ref_foo_3_const, u, x1, x2, x3);
-  tgr += new_thread(&U::ref_foo_const_ref_3, u, x1, x2, x3);
-  tgr += new_thread(&U::ref_foo_const_ref_3_const, u, x1, x2, x3);
-  tgr += new_thread(&U::ref_foo_ref_3, u, x1, x2, x3);
-  tgr += new_thread(&U::ref_foo_ref_3_const, u, x1, x2, x3);
-  tgcr += new_thread(&U::const_ref_foo_3, u, x1, x2, x3);
-  tgcr += new_thread(&U::const_ref_foo_3_const, u, x1, x2, x3);
-  tgcr += new_thread(&U::const_ref_foo_const_ref_3, u, x1, x2, x3);
-  tgcr += new_thread(&U::const_ref_foo_const_ref_3_const, u, x1, x2, x3);
-  tgcr += new_thread(&U::const_ref_foo_ref_3, u, x1, x2, x3);
-  tgcr += new_thread(&U::const_ref_foo_ref_3_const, u, x1, x2, x3);
-  tgcr += new_thread(&U::virtual_const_ref_foo_3, u, x1, x2, x3);
-  tgcr += new_thread(&U::virtual_const_ref_foo_3_const, u, x1, x2, x3);
-  tgcr += new_thread(&U::virtual_const_ref_foo_const_ref_3, u, x1, x2, x3);
-  tgcr +=
-    new_thread(&U::virtual_const_ref_foo_const_ref_3_const, u, x1, x2, x3);
-  tgcr += new_thread(&U::virtual_const_ref_foo_ref_3, u, x1, x2, x3);
-  tgcr += new_thread(&U::virtual_const_ref_foo_ref_3_const, u, x1, x2, x3);
-  tg += new_thread(&U::foo_3, u, x1, x2, x3);
-  tg += new_thread(&U::foo_3_const, u, x1, x2, x3);
-  tg += new_thread(&U::foo_const_ref_3, u, x1, x2, x3);
-  tg += new_thread(&U::foo_const_ref_3_const, u, x1, x2, x3);
-  tg += new_thread(&U::foo_ref_3, u, x1, x2, x3);
-  tg += new_thread(&U::foo_ref_3_const, u, x1, x2, x3);
-  tgr += new_thread(&U::virtual_ref_foo_3, u, x1, x2, x3);
-  tgr += new_thread(&U::virtual_ref_foo_3_const, u, x1, x2, x3);
-  tgr += new_thread(&U::virtual_ref_foo_const_ref_3, u, x1, x2, x3);
-  tgr += new_thread(&U::virtual_ref_foo_const_ref_3_const, u, x1, x2, x3);
-  tgr += new_thread(&U::virtual_ref_foo_ref_3, u, x1, x2, x3);
-  tgr += new_thread(&U::virtual_ref_foo_ref_3_const, u, x1, x2, x3);
-  tg += new_thread(&U::virtual_foo_3, u, x1, x2, x3);
-  tg += new_thread(&U::virtual_foo_3_const, u, x1, x2, x3);
-  tg += new_thread(&U::virtual_foo_const_ref_3, u, x1, x2, x3);
-  tg += new_thread(&U::virtual_foo_const_ref_3_const, u, x1, x2, x3);
-  tg += new_thread(&U::virtual_foo_ref_3, u, x1, x2, x3);
-  tg += new_thread(&U::virtual_foo_ref_3_const, u, x1, x2, x3);
-
-  tgr += new_thread(&U::static_ref_foo_3, x1, x2, x3);
-  tgr += new_thread(&U::static_ref_foo_const_ref_3, x1, x2, x3);
-  tgr += new_thread(&U::static_ref_foo_ref_3, x1, x2, x3);
-  tgcr += new_thread(&U::static_const_ref_foo_3, x1, x2, x3);
-  tgcr += new_thread(&U::static_const_ref_foo_const_ref_3, x1, x2, x3);
-  tgcr += new_thread(&U::static_const_ref_foo_ref_3, x1, x2, x3);
-  tg += new_thread(&U::static_foo_3, x1, x2, x3);
-  tg += new_thread(&U::static_foo_const_ref_3, x1, x2, x3);
-  tg += new_thread(&U::static_foo_ref_3, x1, x2, x3);
-  tgr += new_thread(&U::ref_foo_4, u, x1, x2, x3, x4);
-  tgr += new_thread(&U::ref_foo_4_const, u, x1, x2, x3, x4);
-  tgr += new_thread(&U::ref_foo_const_ref_4, u, x1, x2, x3, x4);
-  tgr += new_thread(&U::ref_foo_const_ref_4_const, u, x1, x2, x3, x4);
-  tgr += new_thread(&U::ref_foo_ref_4, u, x1, x2, x3, x4);
-  tgr += new_thread(&U::ref_foo_ref_4_const, u, x1, x2, x3, x4);
-  tgcr += new_thread(&U::const_ref_foo_4, u, x1, x2, x3, x4);
-  tgcr += new_thread(&U::const_ref_foo_4_const, u, x1, x2, x3, x4);
-  tgcr += new_thread(&U::const_ref_foo_const_ref_4, u, x1, x2, x3, x4);
-  tgcr += new_thread(&U::const_ref_foo_const_ref_4_const, u, x1, x2, x3, x4);
-  tgcr += new_thread(&U::const_ref_foo_ref_4, u, x1, x2, x3, x4);
-  tgcr += new_thread(&U::const_ref_foo_ref_4_const, u, x1, x2, x3, x4);
-  tgcr += new_thread(&U::virtual_const_ref_foo_4, u, x1, x2, x3, x4);
-  tgcr += new_thread(&U::virtual_const_ref_foo_4_const, u, x1, x2, x3, x4);
-  tgcr += new_thread(&U::virtual_const_ref_foo_const_ref_4, u, x1, x2, x3, x4);
-  tgcr +=
-    new_thread(&U::virtual_const_ref_foo_const_ref_4_const, u, x1, x2, x3, x4);
-  tgcr += new_thread(&U::virtual_const_ref_foo_ref_4, u, x1, x2, x3, x4);
-  tgcr += new_thread(&U::virtual_const_ref_foo_ref_4_const, u, x1, x2, x3, x4);
-  tg += new_thread(&U::foo_4, u, x1, x2, x3, x4);
-  tg += new_thread(&U::foo_4_const, u, x1, x2, x3, x4);
-  tg += new_thread(&U::foo_const_ref_4, u, x1, x2, x3, x4);
-  tg += new_thread(&U::foo_const_ref_4_const, u, x1, x2, x3, x4);
-  tg += new_thread(&U::foo_ref_4, u, x1, x2, x3, x4);
-  tg += new_thread(&U::foo_ref_4_const, u, x1, x2, x3, x4);
-  tgr += new_thread(&U::virtual_ref_foo_4, u, x1, x2, x3, x4);
-  tgr += new_thread(&U::virtual_ref_foo_4_const, u, x1, x2, x3, x4);
-  tgr += new_thread(&U::virtual_ref_foo_const_ref_4, u, x1, x2, x3, x4);
-  tgr += new_thread(&U::virtual_ref_foo_const_ref_4_const, u, x1, x2, x3, x4);
-  tgr += new_thread(&U::virtual_ref_foo_ref_4, u, x1, x2, x3, x4);
-  tgr += new_thread(&U::virtual_ref_foo_ref_4_const, u, x1, x2, x3, x4);
-  tg += new_thread(&U::virtual_foo_4, u, x1, x2, x3, x4);
-  tg += new_thread(&U::virtual_foo_4_const, u, x1, x2, x3, x4);
-  tg += new_thread(&U::virtual_foo_const_ref_4, u, x1, x2, x3, x4);
-  tg += new_thread(&U::virtual_foo_const_ref_4_const, u, x1, x2, x3, x4);
-  tg += new_thread(&U::virtual_foo_ref_4, u, x1, x2, x3, x4);
-  tg += new_thread(&U::virtual_foo_ref_4_const, u, x1, x2, x3, x4);
-
-  tgr += new_thread(&U::static_ref_foo_4, x1, x2, x3, x4);
-  tgr += new_thread(&U::static_ref_foo_const_ref_4, x1, x2, x3, x4);
-  tgr += new_thread(&U::static_ref_foo_ref_4, x1, x2, x3, x4);
-  tgcr += new_thread(&U::static_const_ref_foo_4, x1, x2, x3, x4);
-  tgcr += new_thread(&U::static_const_ref_foo_const_ref_4, x1, x2, x3, x4);
-  tgcr += new_thread(&U::static_const_ref_foo_ref_4, x1, x2, x3, x4);
-  tg += new_thread(&U::static_foo_4, x1, x2, x3, x4);
-  tg += new_thread(&U::static_foo_const_ref_4, x1, x2, x3, x4);
-  tg += new_thread(&U::static_foo_ref_4, x1, x2, x3, x4);
-  tgr += new_thread(&U::ref_foo_5, u, x1, x2, x3, x4, x5);
-  tgr += new_thread(&U::ref_foo_5_const, u, x1, x2, x3, x4, x5);
-  tgr += new_thread(&U::ref_foo_const_ref_5, u, x1, x2, x3, x4, x5);
-  tgr += new_thread(&U::ref_foo_const_ref_5_const, u, x1, x2, x3, x4, x5);
-  tgr += new_thread(&U::ref_foo_ref_5, u, x1, x2, x3, x4, x5);
-  tgr += new_thread(&U::ref_foo_ref_5_const, u, x1, x2, x3, x4, x5);
-  tgcr += new_thread(&U::const_ref_foo_5, u, x1, x2, x3, x4, x5);
-  tgcr += new_thread(&U::const_ref_foo_5_const, u, x1, x2, x3, x4, x5);
-  tgcr += new_thread(&U::const_ref_foo_const_ref_5, u, x1, x2, x3, x4, x5);
-  tgcr +=
-    new_thread(&U::const_ref_foo_const_ref_5_const, u, x1, x2, x3, x4, x5);
-  tgcr += new_thread(&U::const_ref_foo_ref_5, u, x1, x2, x3, x4, x5);
-  tgcr += new_thread(&U::const_ref_foo_ref_5_const, u, x1, x2, x3, x4, x5);
-  tgcr += new_thread(&U::virtual_const_ref_foo_5, u, x1, x2, x3, x4, x5);
-  tgcr += new_thread(&U::virtual_const_ref_foo_5_const, u, x1, x2, x3, x4, x5);
-  tgcr +=
-    new_thread(&U::virtual_const_ref_foo_const_ref_5, u, x1, x2, x3, x4, x5);
-  tgcr += new_thread(
-    &U::virtual_const_ref_foo_const_ref_5_const, u, x1, x2, x3, x4, x5);
-  tgcr += new_thread(&U::virtual_const_ref_foo_ref_5, u, x1, x2, x3, x4, x5);
-  tgcr +=
-    new_thread(&U::virtual_const_ref_foo_ref_5_const, u, x1, x2, x3, x4, x5);
-  tg += new_thread(&U::foo_5, u, x1, x2, x3, x4, x5);
-  tg += new_thread(&U::foo_5_const, u, x1, x2, x3, x4, x5);
-  tg += new_thread(&U::foo_const_ref_5, u, x1, x2, x3, x4, x5);
-  tg += new_thread(&U::foo_const_ref_5_const, u, x1, x2, x3, x4, x5);
-  tg += new_thread(&U::foo_ref_5, u, x1, x2, x3, x4, x5);
-  tg += new_thread(&U::foo_ref_5_const, u, x1, x2, x3, x4, x5);
-  tgr += new_thread(&U::virtual_ref_foo_5, u, x1, x2, x3, x4, x5);
-  tgr += new_thread(&U::virtual_ref_foo_5_const, u, x1, x2, x3, x4, x5);
-  tgr += new_thread(&U::virtual_ref_foo_const_ref_5, u, x1, x2, x3, x4, x5);
-  tgr +=
-    new_thread(&U::virtual_ref_foo_const_ref_5_const, u, x1, x2, x3, x4, x5);
-  tgr += new_thread(&U::virtual_ref_foo_ref_5, u, x1, x2, x3, x4, x5);
-  tgr += new_thread(&U::virtual_ref_foo_ref_5_const, u, x1, x2, x3, x4, x5);
-  tg += new_thread(&U::virtual_foo_5, u, x1, x2, x3, x4, x5);
-  tg += new_thread(&U::virtual_foo_5_const, u, x1, x2, x3, x4, x5);
-  tg += new_thread(&U::virtual_foo_const_ref_5, u, x1, x2, x3, x4, x5);
-  tg += new_thread(&U::virtual_foo_const_ref_5_const, u, x1, x2, x3, x4, x5);
-  tg += new_thread(&U::virtual_foo_ref_5, u, x1, x2, x3, x4, x5);
-  tg += new_thread(&U::virtual_foo_ref_5_const, u, x1, x2, x3, x4, x5);
-
-  tgr += new_thread(&U::static_ref_foo_5, x1, x2, x3, x4, x5);
-  tgr += new_thread(&U::static_ref_foo_const_ref_5, x1, x2, x3, x4, x5);
-  tgr += new_thread(&U::static_ref_foo_ref_5, x1, x2, x3, x4, x5);
-  tgcr += new_thread(&U::static_const_ref_foo_5, x1, x2, x3, x4, x5);
-  tgcr += new_thread(&U::static_const_ref_foo_const_ref_5, x1, x2, x3, x4, x5);
-  tgcr += new_thread(&U::static_const_ref_foo_ref_5, x1, x2, x3, x4, x5);
-  tg += new_thread(&U::static_foo_5, x1, x2, x3, x4, x5);
-  tg += new_thread(&U::static_foo_const_ref_5, x1, x2, x3, x4, x5);
-  tg += new_thread(&U::static_foo_ref_5, x1, x2, x3, x4, x5);
-  tgr += new_thread(&U::ref_foo_6, u, x1, x2, x3, x4, x5, x6);
-  tgr += new_thread(&U::ref_foo_6_const, u, x1, x2, x3, x4, x5, x6);
-  tgr += new_thread(&U::ref_foo_const_ref_6, u, x1, x2, x3, x4, x5, x6);
-  tgr += new_thread(&U::ref_foo_const_ref_6_const, u, x1, x2, x3, x4, x5, x6);
-  tgr += new_thread(&U::ref_foo_ref_6, u, x1, x2, x3, x4, x5, x6);
-  tgr += new_thread(&U::ref_foo_ref_6_const, u, x1, x2, x3, x4, x5, x6);
-  tgcr += new_thread(&U::const_ref_foo_6, u, x1, x2, x3, x4, x5, x6);
-  tgcr += new_thread(&U::const_ref_foo_6_const, u, x1, x2, x3, x4, x5, x6);
-  tgcr += new_thread(&U::const_ref_foo_const_ref_6, u, x1, x2, x3, x4, x5, x6);
-  tgcr +=
-    new_thread(&U::const_ref_foo_const_ref_6_const, u, x1, x2, x3, x4, x5, x6);
-  tgcr += new_thread(&U::const_ref_foo_ref_6, u, x1, x2, x3, x4, x5, x6);
-  tgcr += new_thread(&U::const_ref_foo_ref_6_const, u, x1, x2, x3, x4, x5, x6);
-  tgcr += new_thread(&U::virtual_const_ref_foo_6, u, x1, x2, x3, x4, x5, x6);
-  tgcr +=
-    new_thread(&U::virtual_const_ref_foo_6_const, u, x1, x2, x3, x4, x5, x6);
-  tgcr += new_thread(
-    &U::virtual_const_ref_foo_const_ref_6, u, x1, x2, x3, x4, x5, x6);
-  tgcr += new_thread(
-    &U::virtual_const_ref_foo_const_ref_6_const, u, x1, x2, x3, x4, x5, x6);
-  tgcr +=
-    new_thread(&U::virtual_const_ref_foo_ref_6, u, x1, x2, x3, x4, x5, x6);
-  tgcr += new_thread(
-    &U::virtual_const_ref_foo_ref_6_const, u, x1, x2, x3, x4, x5, x6);
-  tg += new_thread(&U::foo_6, u, x1, x2, x3, x4, x5, x6);
-  tg += new_thread(&U::foo_6_const, u, x1, x2, x3, x4, x5, x6);
-  tg += new_thread(&U::foo_const_ref_6, u, x1, x2, x3, x4, x5, x6);
-  tg += new_thread(&U::foo_const_ref_6_const, u, x1, x2, x3, x4, x5, x6);
-  tg += new_thread(&U::foo_ref_6, u, x1, x2, x3, x4, x5, x6);
-  tg += new_thread(&U::foo_ref_6_const, u, x1, x2, x3, x4, x5, x6);
-  tgr += new_thread(&U::virtual_ref_foo_6, u, x1, x2, x3, x4, x5, x6);
-  tgr += new_thread(&U::virtual_ref_foo_6_const, u, x1, x2, x3, x4, x5, x6);
-  tgr += new_thread(&U::virtual_ref_foo_const_ref_6, u, x1, x2, x3, x4, x5, x6);
-  tgr += new_thread(
-    &U::virtual_ref_foo_const_ref_6_const, u, x1, x2, x3, x4, x5, x6);
-  tgr += new_thread(&U::virtual_ref_foo_ref_6, u, x1, x2, x3, x4, x5, x6);
-  tgr += new_thread(&U::virtual_ref_foo_ref_6_const, u, x1, x2, x3, x4, x5, x6);
-  tg += new_thread(&U::virtual_foo_6, u, x1, x2, x3, x4, x5, x6);
-  tg += new_thread(&U::virtual_foo_6_const, u, x1, x2, x3, x4, x5, x6);
-  tg += new_thread(&U::virtual_foo_const_ref_6, u, x1, x2, x3, x4, x5, x6);
-  tg +=
-    new_thread(&U::virtual_foo_const_ref_6_const, u, x1, x2, x3, x4, x5, x6);
-  tg += new_thread(&U::virtual_foo_ref_6, u, x1, x2, x3, x4, x5, x6);
-  tg += new_thread(&U::virtual_foo_ref_6_const, u, x1, x2, x3, x4, x5, x6);
-
-  tgr += new_thread(&U::static_ref_foo_6, x1, x2, x3, x4, x5, x6);
-  tgr += new_thread(&U::static_ref_foo_const_ref_6, x1, x2, x3, x4, x5, x6);
-  tgr += new_thread(&U::static_ref_foo_ref_6, x1, x2, x3, x4, x5, x6);
-  tgcr += new_thread(&U::static_const_ref_foo_6, x1, x2, x3, x4, x5, x6);
-  tgcr +=
-    new_thread(&U::static_const_ref_foo_const_ref_6, x1, x2, x3, x4, x5, x6);
-  tgcr += new_thread(&U::static_const_ref_foo_ref_6, x1, x2, x3, x4, x5, x6);
-  tg += new_thread(&U::static_foo_6, x1, x2, x3, x4, x5, x6);
-  tg += new_thread(&U::static_foo_const_ref_6, x1, x2, x3, x4, x5, x6);
-  tg += new_thread(&U::static_foo_ref_6, x1, x2, x3, x4, x5, x6);
-  tgr += new_thread(&U::ref_foo_7, u, x1, x2, x3, x4, x5, x6, x7);
-  tgr += new_thread(&U::ref_foo_7_const, u, x1, x2, x3, x4, x5, x6, x7);
-  tgr += new_thread(&U::ref_foo_const_ref_7, u, x1, x2, x3, x4, x5, x6, x7);
-  tgr +=
-    new_thread(&U::ref_foo_const_ref_7_const, u, x1, x2, x3, x4, x5, x6, x7);
-  tgr += new_thread(&U::ref_foo_ref_7, u, x1, x2, x3, x4, x5, x6, x7);
-  tgr += new_thread(&U::ref_foo_ref_7_const, u, x1, x2, x3, x4, x5, x6, x7);
-  tgcr += new_thread(&U::const_ref_foo_7, u, x1, x2, x3, x4, x5, x6, x7);
-  tgcr += new_thread(&U::const_ref_foo_7_const, u, x1, x2, x3, x4, x5, x6, x7);
-  tgcr +=
-    new_thread(&U::const_ref_foo_const_ref_7, u, x1, x2, x3, x4, x5, x6, x7);
-  tgcr += new_thread(
-    &U::const_ref_foo_const_ref_7_const, u, x1, x2, x3, x4, x5, x6, x7);
-  tgcr += new_thread(&U::const_ref_foo_ref_7, u, x1, x2, x3, x4, x5, x6, x7);
-  tgcr +=
-    new_thread(&U::const_ref_foo_ref_7_const, u, x1, x2, x3, x4, x5, x6, x7);
-  tgcr +=
-    new_thread(&U::virtual_const_ref_foo_7, u, x1, x2, x3, x4, x5, x6, x7);
-  tgcr += new_thread(
-    &U::virtual_const_ref_foo_7_const, u, x1, x2, x3, x4, x5, x6, x7);
-  tgcr += new_thread(
-    &U::virtual_const_ref_foo_const_ref_7, u, x1, x2, x3, x4, x5, x6, x7);
-  tgcr += new_thread(
-    &U::virtual_const_ref_foo_const_ref_7_const, u, x1, x2, x3, x4, x5, x6, x7);
-  tgcr +=
-    new_thread(&U::virtual_const_ref_foo_ref_7, u, x1, x2, x3, x4, x5, x6, x7);
-  tgcr += new_thread(
-    &U::virtual_const_ref_foo_ref_7_const, u, x1, x2, x3, x4, x5, x6, x7);
-  tg += new_thread(&U::foo_7, u, x1, x2, x3, x4, x5, x6, x7);
-  tg += new_thread(&U::foo_7_const, u, x1, x2, x3, x4, x5, x6, x7);
-  tg += new_thread(&U::foo_const_ref_7, u, x1, x2, x3, x4, x5, x6, x7);
-  tg += new_thread(&U::foo_const_ref_7_const, u, x1, x2, x3, x4, x5, x6, x7);
-  tg += new_thread(&U::foo_ref_7, u, x1, x2, x3, x4, x5, x6, x7);
-  tg += new_thread(&U::foo_ref_7_const, u, x1, x2, x3, x4, x5, x6, x7);
-  tgr += new_thread(&U::virtual_ref_foo_7, u, x1, x2, x3, x4, x5, x6, x7);
-  tgr += new_thread(&U::virtual_ref_foo_7_const, u, x1, x2, x3, x4, x5, x6, x7);
-  tgr +=
-    new_thread(&U::virtual_ref_foo_const_ref_7, u, x1, x2, x3, x4, x5, x6, x7);
-  tgr += new_thread(
-    &U::virtual_ref_foo_const_ref_7_const, u, x1, x2, x3, x4, x5, x6, x7);
-  tgr += new_thread(&U::virtual_ref_foo_ref_7, u, x1, x2, x3, x4, x5, x6, x7);
-  tgr +=
-    new_thread(&U::virtual_ref_foo_ref_7_const, u, x1, x2, x3, x4, x5, x6, x7);
-  tg += new_thread(&U::virtual_foo_7, u, x1, x2, x3, x4, x5, x6, x7);
-  tg += new_thread(&U::virtual_foo_7_const, u, x1, x2, x3, x4, x5, x6, x7);
-  tg += new_thread(&U::virtual_foo_const_ref_7, u, x1, x2, x3, x4, x5, x6, x7);
-  tg += new_thread(
-    &U::virtual_foo_const_ref_7_const, u, x1, x2, x3, x4, x5, x6, x7);
-  tg += new_thread(&U::virtual_foo_ref_7, u, x1, x2, x3, x4, x5, x6, x7);
-  tg += new_thread(&U::virtual_foo_ref_7_const, u, x1, x2, x3, x4, x5, x6, x7);
-
-  tgr += new_thread(&U::static_ref_foo_7, x1, x2, x3, x4, x5, x6, x7);
-  tgr += new_thread(&U::static_ref_foo_const_ref_7, x1, x2, x3, x4, x5, x6, x7);
-  tgr += new_thread(&U::static_ref_foo_ref_7, x1, x2, x3, x4, x5, x6, x7);
-  tgcr += new_thread(&U::static_const_ref_foo_7, x1, x2, x3, x4, x5, x6, x7);
-  tgcr += new_thread(
-    &U::static_const_ref_foo_const_ref_7, x1, x2, x3, x4, x5, x6, x7);
-  tgcr +=
-    new_thread(&U::static_const_ref_foo_ref_7, x1, x2, x3, x4, x5, x6, x7);
-  tg += new_thread(&U::static_foo_7, x1, x2, x3, x4, x5, x6, x7);
-  tg += new_thread(&U::static_foo_const_ref_7, x1, x2, x3, x4, x5, x6, x7);
-  tg += new_thread(&U::static_foo_ref_7, x1, x2, x3, x4, x5, x6, x7);
-  tgr += new_thread(&U::ref_foo_8, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgr += new_thread(&U::ref_foo_8_const, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgr += new_thread(&U::ref_foo_const_ref_8, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgr += new_thread(
-    &U::ref_foo_const_ref_8_const, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgr += new_thread(&U::ref_foo_ref_8, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgr += new_thread(&U::ref_foo_ref_8_const, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgcr += new_thread(&U::const_ref_foo_8, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgcr +=
-    new_thread(&U::const_ref_foo_8_const, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgcr += new_thread(
-    &U::const_ref_foo_const_ref_8, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgcr += new_thread(
-    &U::const_ref_foo_const_ref_8_const, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgcr +=
-    new_thread(&U::const_ref_foo_ref_8, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgcr += new_thread(
-    &U::const_ref_foo_ref_8_const, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgcr +=
-    new_thread(&U::virtual_const_ref_foo_8, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgcr += new_thread(
-    &U::virtual_const_ref_foo_8_const, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgcr += new_thread(
-    &U::virtual_const_ref_foo_const_ref_8, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgcr += new_thread(&U::virtual_const_ref_foo_const_ref_8_const,
-                     u,
-                     x1,
-                     x2,
-                     x3,
-                     x4,
-                     x5,
-                     x6,
-                     x7,
-                     x8);
-  tgcr += new_thread(
-    &U::virtual_const_ref_foo_ref_8, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgcr += new_thread(
-    &U::virtual_const_ref_foo_ref_8_const, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tg += new_thread(&U::foo_8, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tg += new_thread(&U::foo_8_const, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tg += new_thread(&U::foo_const_ref_8, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tg +=
-    new_thread(&U::foo_const_ref_8_const, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tg += new_thread(&U::foo_ref_8, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tg += new_thread(&U::foo_ref_8_const, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgr += new_thread(&U::virtual_ref_foo_8, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgr +=
-    new_thread(&U::virtual_ref_foo_8_const, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgr += new_thread(
-    &U::virtual_ref_foo_const_ref_8, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgr += new_thread(
-    &U::virtual_ref_foo_const_ref_8_const, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgr +=
-    new_thread(&U::virtual_ref_foo_ref_8, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgr += new_thread(
-    &U::virtual_ref_foo_ref_8_const, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tg += new_thread(&U::virtual_foo_8, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tg += new_thread(&U::virtual_foo_8_const, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tg +=
-    new_thread(&U::virtual_foo_const_ref_8, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tg += new_thread(
-    &U::virtual_foo_const_ref_8_const, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tg += new_thread(&U::virtual_foo_ref_8, u, x1, x2, x3, x4, x5, x6, x7, x8);
-  tg +=
-    new_thread(&U::virtual_foo_ref_8_const, u, x1, x2, x3, x4, x5, x6, x7, x8);
-
-  tgr += new_thread(&U::static_ref_foo_8, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgr +=
-    new_thread(&U::static_ref_foo_const_ref_8, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgr += new_thread(&U::static_ref_foo_ref_8, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgcr +=
-    new_thread(&U::static_const_ref_foo_8, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgcr += new_thread(
-    &U::static_const_ref_foo_const_ref_8, x1, x2, x3, x4, x5, x6, x7, x8);
-  tgcr +=
-    new_thread(&U::static_const_ref_foo_ref_8, x1, x2, x3, x4, x5, x6, x7, x8);
-  tg += new_thread(&U::static_foo_8, x1, x2, x3, x4, x5, x6, x7, x8);
-  tg += new_thread(&U::static_foo_const_ref_8, x1, x2, x3, x4, x5, x6, x7, x8);
-  tg += new_thread(&U::static_foo_ref_8, x1, x2, x3, x4, x5, x6, x7, x8);
-  tg.join_all();
-  tgr.join_all();
-  tgcr.join_all();
-
-  std::ofstream *out_stream =
-    dynamic_cast<std::ofstream *>(&deallog.get_file_stream());
-  Assert(out_stream != nullptr, ExcInternalError());
-  deallog.detach();
-  out_stream->close();
-  sort_file_contents("output");
-}

diff --git a/tests/multithreading/threads_02.output b/tests/multithreading/threads_02.output
deleted file mode 100644 (file)
index e7ee602..0000000
--- a/tests/multithreading/threads_02.output
+++ /dev/null
@@ -1,406 +0,0 @@
-DEAL::X<0> U::foo_0()
-DEAL::X<0> U::foo_0_const() const
-DEAL::X<0> U::foo_1(X<1>)
-DEAL::X<0> U::foo_1_const(X<1>) const
-DEAL::X<0> U::foo_2(X<1>, X<2>)
-DEAL::X<0> U::foo_2_const(X<1>, X<2>) const
-DEAL::X<0> U::foo_3(X<1>, X<2>, X<3>)
-DEAL::X<0> U::foo_3_const(X<1>, X<2>, X<3>) const
-DEAL::X<0> U::foo_4(X<1>, X<2>, X<3>, X<4>)
-DEAL::X<0> U::foo_4_const(X<1>, X<2>, X<3>, X<4>) const
-DEAL::X<0> U::foo_5(X<1>, X<2>, X<3>, X<4>, X<5>)
-DEAL::X<0> U::foo_5_const(X<1>, X<2>, X<3>, X<4>, X<5>) const
-DEAL::X<0> U::foo_6(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>)
-DEAL::X<0> U::foo_6_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>) const
-DEAL::X<0> U::foo_7(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>)
-DEAL::X<0> U::foo_7_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>) const
-DEAL::X<0> U::foo_8(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>)
-DEAL::X<0> U::foo_8_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>) const
-DEAL::X<0> U::foo_const_ref_0()
-DEAL::X<0> U::foo_const_ref_0_const() const
-DEAL::X<0> U::foo_const_ref_1(const X<1>&)
-DEAL::X<0> U::foo_const_ref_1_const(const X<1>&) const
-DEAL::X<0> U::foo_const_ref_2(const X<1>&, const X<2>&)
-DEAL::X<0> U::foo_const_ref_2_const(const X<1>&, const X<2>&) const
-DEAL::X<0> U::foo_const_ref_3(const X<1>&, const X<2>&, const X<3>&)
-DEAL::X<0> U::foo_const_ref_3_const(const X<1>&, const X<2>&, const X<3>&) const
-DEAL::X<0> U::foo_const_ref_4(const X<1>&, const X<2>&, const X<3>&, const X<4>&)
-DEAL::X<0> U::foo_const_ref_4_const(const X<1>&, const X<2>&, const X<3>&, const X<4>&) const
-DEAL::X<0> U::foo_const_ref_5(const X<1>&, const X<2>&, const X<3>&, const X<4>&, const X<5>&)
-DEAL::X<0> U::foo_const_ref_5_const(const X<1>&, const X<2>&, const X<3>&, const X<4>&, const X<5>&) const
-DEAL::X<0> U::foo_const_ref_6(const X<1>&, const X<2>&, const X<3>&, const X<4>&, const X<5>&, const X<6>&)
-DEAL::X<0> U::foo_const_ref_6_const(const X<1>&, const X<2>&, const X<3>&, const X<4>&, const X<5>&, const X<6>&) const
-DEAL::X<0> U::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>&)
-DEAL::X<0> U::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
-DEAL::X<0> U::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>&)
-DEAL::X<0> U::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
-DEAL::X<0> U::foo_ref_0()
-DEAL::X<0> U::foo_ref_0_const() const
-DEAL::X<0> U::foo_ref_1(X<1>&)
-DEAL::X<0> U::foo_ref_1_const(X<1>&) const
-DEAL::X<0> U::foo_ref_2(X<1>&, X<2>&)
-DEAL::X<0> U::foo_ref_2_const(X<1>&, X<2>&) const
-DEAL::X<0> U::foo_ref_3(X<1>&, X<2>&, X<3>&)
-DEAL::X<0> U::foo_ref_3_const(X<1>&, X<2>&, X<3>&) const
-DEAL::X<0> U::foo_ref_4(X<1>&, X<2>&, X<3>&, X<4>&)
-DEAL::X<0> U::foo_ref_4_const(X<1>&, X<2>&, X<3>&, X<4>&) const
-DEAL::X<0> U::foo_ref_5(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&)
-DEAL::X<0> U::foo_ref_5_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&) const
-DEAL::X<0> U::foo_ref_6(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&)
-DEAL::X<0> U::foo_ref_6_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&) const
-DEAL::X<0> U::foo_ref_7(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&)
-DEAL::X<0> U::foo_ref_7_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&) const
-DEAL::X<0> U::foo_ref_8(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&, X<8>&)
-DEAL::X<0> U::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::virtual_foo_0()
-DEAL::X<0> U::virtual_foo_0_const() const
-DEAL::X<0> U::virtual_foo_1(X<1>)
-DEAL::X<0> U::virtual_foo_1_const(X<1>) const
-DEAL::X<0> U::virtual_foo_2(X<1>, X<2>)
-DEAL::X<0> U::virtual_foo_2_const(X<1>, X<2>) const
-DEAL::X<0> U::virtual_foo_3(X<1>, X<2>, X<3>)
-DEAL::X<0> U::virtual_foo_3_const(X<1>, X<2>, X<3>) const
-DEAL::X<0> U::virtual_foo_4(X<1>, X<2>, X<3>, X<4>)
-DEAL::X<0> U::virtual_foo_4_const(X<1>, X<2>, X<3>, X<4>) const
-DEAL::X<0> U::virtual_foo_5(X<1>, X<2>, X<3>, X<4>, X<5>)
-DEAL::X<0> U::virtual_foo_5_const(X<1>, X<2>, X<3>, X<4>, X<5>) const
-DEAL::X<0> U::virtual_foo_6(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>)
-DEAL::X<0> U::virtual_foo_6_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>) const
-DEAL::X<0> U::virtual_foo_7(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>)
-DEAL::X<0> U::virtual_foo_7_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>) const
-DEAL::X<0> U::virtual_foo_8(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>)
-DEAL::X<0> U::virtual_foo_8_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>) const
-DEAL::X<0> U::virtual_foo_const_ref_0()
-DEAL::X<0> U::virtual_foo_const_ref_0_const() const
-DEAL::X<0> U::virtual_foo_const_ref_1(const X<1>&)
-DEAL::X<0> U::virtual_foo_const_ref_1_const(const X<1>&) const
-DEAL::X<0> U::virtual_foo_const_ref_2(const X<1>&, const X<2>&)
-DEAL::X<0> U::virtual_foo_const_ref_2_const(const X<1>&, const X<2>&) const
-DEAL::X<0> U::virtual_foo_const_ref_3(const X<1>&, const X<2>&, const X<3>&)
-DEAL::X<0> U::virtual_foo_const_ref_3_const(const X<1>&, const X<2>&, const X<3>&) const
-DEAL::X<0> U::virtual_foo_const_ref_4(const X<1>&, const X<2>&, const X<3>&, const X<4>&)
-DEAL::X<0> U::virtual_foo_const_ref_4_const(const X<1>&, const X<2>&, const X<3>&, const X<4>&) const
-DEAL::X<0> U::virtual_foo_const_ref_5(const X<1>&, const X<2>&, const X<3>&, const X<4>&, const X<5>&)
-DEAL::X<0> U::virtual_foo_const_ref_5_const(const X<1>&, const X<2>&, const X<3>&, const X<4>&, const X<5>&) const
-DEAL::X<0> U::virtual_foo_const_ref_6(const X<1>&, const X<2>&, const X<3>&, const X<4>&, const X<5>&, const X<6>&)
-DEAL::X<0> U::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
-DEAL::X<0> U::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>&)
-DEAL::X<0> U::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
-DEAL::X<0> U::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>&)
-DEAL::X<0> U::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
-DEAL::X<0> U::virtual_foo_ref_0()
-DEAL::X<0> U::virtual_foo_ref_0_const() const
-DEAL::X<0> U::virtual_foo_ref_1(X<1>&)
-DEAL::X<0> U::virtual_foo_ref_1_const(X<1>&) const
-DEAL::X<0> U::virtual_foo_ref_2(X<1>&, X<2>&)
-DEAL::X<0> U::virtual_foo_ref_2_const(X<1>&, X<2>&) const
-DEAL::X<0> U::virtual_foo_ref_3(X<1>&, X<2>&, X<3>&)
-DEAL::X<0> U::virtual_foo_ref_3_const(X<1>&, X<2>&, X<3>&) const
-DEAL::X<0> U::virtual_foo_ref_4(X<1>&, X<2>&, X<3>&, X<4>&)
-DEAL::X<0> U::virtual_foo_ref_4_const(X<1>&, X<2>&, X<3>&, X<4>&) const
-DEAL::X<0> U::virtual_foo_ref_5(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&)
-DEAL::X<0> U::virtual_foo_ref_5_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&) const
-DEAL::X<0> U::virtual_foo_ref_6(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&)
-DEAL::X<0> U::virtual_foo_ref_6_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&) const
-DEAL::X<0> U::virtual_foo_ref_7(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&)
-DEAL::X<0> U::virtual_foo_ref_7_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&) const
-DEAL::X<0> U::virtual_foo_ref_8(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&, X<8>&)
-DEAL::X<0> U::virtual_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_0()
-DEAL::X<0>& U::ref_foo_0_const() const
-DEAL::X<0>& U::ref_foo_1(X<1>)
-DEAL::X<0>& U::ref_foo_1_const(X<1>) const
-DEAL::X<0>& U::ref_foo_2(X<1>, X<2>)
-DEAL::X<0>& U::ref_foo_2_const(X<1>, X<2>) const
-DEAL::X<0>& U::ref_foo_3(X<1>, X<2>, X<3>)
-DEAL::X<0>& U::ref_foo_3_const(X<1>, X<2>, X<3>) const
-DEAL::X<0>& U::ref_foo_4(X<1>, X<2>, X<3>, X<4>)
-DEAL::X<0>& U::ref_foo_4_const(X<1>, X<2>, X<3>, X<4>) const
-DEAL::X<0>& U::ref_foo_5(X<1>, X<2>, X<3>, X<4>, X<5>)
-DEAL::X<0>& U::ref_foo_5_const(X<1>, X<2>, X<3>, X<4>, X<5>) const
-DEAL::X<0>& U::ref_foo_6(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>)
-DEAL::X<0>& U::ref_foo_6_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>) const
-DEAL::X<0>& U::ref_foo_7(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>)
-DEAL::X<0>& U::ref_foo_7_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>) const
-DEAL::X<0>& U::ref_foo_8(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>)
-DEAL::X<0>& U::ref_foo_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_const_ref_0()
-DEAL::X<0>& U::ref_foo_const_ref_0_const() const
-DEAL::X<0>& U::ref_foo_const_ref_1(const X<1>&)
-DEAL::X<0>& U::ref_foo_const_ref_1_const(const X<1>&) const
-DEAL::X<0>& U::ref_foo_const_ref_2(const X<1>&, const X<2>&)
-DEAL::X<0>& U::ref_foo_const_ref_2_const(const X<1>&, const X<2>&) const
-DEAL::X<0>& U::ref_foo_const_ref_3(const X<1>&, const X<2>&, const X<3>&)
-DEAL::X<0>& U::ref_foo_const_ref_3_const(const X<1>&, const X<2>&, const X<3>&) const
-DEAL::X<0>& U::ref_foo_const_ref_4(const X<1>&, const X<2>&, const X<3>&, const X<4>&)
-DEAL::X<0>& U::ref_foo_const_ref_4_const(const X<1>&, const X<2>&, const X<3>&, const X<4>&) const
-DEAL::X<0>& U::ref_foo_const_ref_5(const X<1>&, const X<2>&, const X<3>&, const X<4>&, const X<5>&)
-DEAL::X<0>& U::ref_foo_const_ref_5_const(const X<1>&, const X<2>&, const X<3>&, const X<4>&, const X<5>&) const
-DEAL::X<0>& U::ref_foo_const_ref_6(const X<1>&, const X<2>&, const X<3>&, const X<4>&, const X<5>&, const X<6>&)
-DEAL::X<0>& U::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
-DEAL::X<0>& U::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>&)
-DEAL::X<0>& U::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
-DEAL::X<0>& U::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>&)
-DEAL::X<0>& U::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
-DEAL::X<0>& U::ref_foo_ref_0()
-DEAL::X<0>& U::ref_foo_ref_0_const() const
-DEAL::X<0>& U::ref_foo_ref_1(X<1>&)
-DEAL::X<0>& U::ref_foo_ref_1_const(X<1>&) const
-DEAL::X<0>& U::ref_foo_ref_2(X<1>&, X<2>&)
-DEAL::X<0>& U::ref_foo_ref_2_const(X<1>&, X<2>&) const
-DEAL::X<0>& U::ref_foo_ref_3(X<1>&, X<2>&, X<3>&)
-DEAL::X<0>& U::ref_foo_ref_3_const(X<1>&, X<2>&, X<3>&) const
-DEAL::X<0>& U::ref_foo_ref_4(X<1>&, X<2>&, X<3>&, X<4>&)
-DEAL::X<0>& U::ref_foo_ref_4_const(X<1>&, X<2>&, X<3>&, X<4>&) const
-DEAL::X<0>& U::ref_foo_ref_5(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&)
-DEAL::X<0>& U::ref_foo_ref_5_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&) const
-DEAL::X<0>& U::ref_foo_ref_6(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&)
-DEAL::X<0>& U::ref_foo_ref_6_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&) const
-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_7_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&) 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>&)
-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::virtual_ref_foo_0()
-DEAL::X<0>& U::virtual_ref_foo_0_const() const
-DEAL::X<0>& U::virtual_ref_foo_1(X<1>)
-DEAL::X<0>& U::virtual_ref_foo_1_const(X<1>) const
-DEAL::X<0>& U::virtual_ref_foo_2(X<1>, X<2>)
-DEAL::X<0>& U::virtual_ref_foo_2_const(X<1>, X<2>) const
-DEAL::X<0>& U::virtual_ref_foo_3(X<1>, X<2>, X<3>)
-DEAL::X<0>& U::virtual_ref_foo_3_const(X<1>, X<2>, X<3>) const
-DEAL::X<0>& U::virtual_ref_foo_4(X<1>, X<2>, X<3>, X<4>)
-DEAL::X<0>& U::virtual_ref_foo_4_const(X<1>, X<2>, X<3>, X<4>) const
-DEAL::X<0>& U::virtual_ref_foo_5(X<1>, X<2>, X<3>, X<4>, X<5>)
-DEAL::X<0>& U::virtual_ref_foo_5_const(X<1>, X<2>, X<3>, X<4>, X<5>) const
-DEAL::X<0>& U::virtual_ref_foo_6(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>)
-DEAL::X<0>& U::virtual_ref_foo_6_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>) const
-DEAL::X<0>& U::virtual_ref_foo_7(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>)
-DEAL::X<0>& U::virtual_ref_foo_7_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>) const
-DEAL::X<0>& U::virtual_ref_foo_8(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>)
-DEAL::X<0>& U::virtual_ref_foo_8_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>) const
-DEAL::X<0>& U::virtual_ref_foo_const_ref_0()
-DEAL::X<0>& U::virtual_ref_foo_const_ref_0_const() const
-DEAL::X<0>& U::virtual_ref_foo_const_ref_1(const X<1>&)
-DEAL::X<0>& U::virtual_ref_foo_const_ref_1_const(const X<1>&) const
-DEAL::X<0>& U::virtual_ref_foo_const_ref_2(const X<1>&, const X<2>&)
-DEAL::X<0>& U::virtual_ref_foo_const_ref_2_const(const X<1>&, const X<2>&) const
-DEAL::X<0>& U::virtual_ref_foo_const_ref_3(const X<1>&, const X<2>&, const X<3>&)
-DEAL::X<0>& U::virtual_ref_foo_const_ref_3_const(const X<1>&, const X<2>&, const X<3>&) const
-DEAL::X<0>& U::virtual_ref_foo_const_ref_4(const X<1>&, const X<2>&, const X<3>&, const X<4>&)
-DEAL::X<0>& U::virtual_ref_foo_const_ref_4_const(const X<1>&, const X<2>&, const X<3>&, const X<4>&) const
-DEAL::X<0>& U::virtual_ref_foo_const_ref_5(const X<1>&, const X<2>&, const X<3>&, const X<4>&, const X<5>&)
-DEAL::X<0>& U::virtual_ref_foo_const_ref_5_const(const X<1>&, const X<2>&, const X<3>&, const X<4>&, const X<5>&) const
-DEAL::X<0>& U::virtual_ref_foo_const_ref_6(const X<1>&, const X<2>&, const X<3>&, const X<4>&, const X<5>&, const X<6>&)
-DEAL::X<0>& U::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
-DEAL::X<0>& U::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>&)
-DEAL::X<0>& U::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
-DEAL::X<0>& U::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>&)
-DEAL::X<0>& U::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
-DEAL::X<0>& U::virtual_ref_foo_ref_0()
-DEAL::X<0>& U::virtual_ref_foo_ref_0_const() const
-DEAL::X<0>& U::virtual_ref_foo_ref_1(X<1>&)
-DEAL::X<0>& U::virtual_ref_foo_ref_1_const(X<1>&) const
-DEAL::X<0>& U::virtual_ref_foo_ref_2(X<1>&, X<2>&)
-DEAL::X<0>& U::virtual_ref_foo_ref_2_const(X<1>&, X<2>&) const
-DEAL::X<0>& U::virtual_ref_foo_ref_3(X<1>&, X<2>&, X<3>&)
-DEAL::X<0>& U::virtual_ref_foo_ref_3_const(X<1>&, X<2>&, X<3>&) const
-DEAL::X<0>& U::virtual_ref_foo_ref_4(X<1>&, X<2>&, X<3>&, X<4>&)
-DEAL::X<0>& U::virtual_ref_foo_ref_4_const(X<1>&, X<2>&, X<3>&, X<4>&) const
-DEAL::X<0>& U::virtual_ref_foo_ref_5(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&)
-DEAL::X<0>& U::virtual_ref_foo_ref_5_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&) const
-DEAL::X<0>& U::virtual_ref_foo_ref_6(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&)
-DEAL::X<0>& U::virtual_ref_foo_ref_6_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&) const
-DEAL::X<0>& U::virtual_ref_foo_ref_7(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&)
-DEAL::X<0>& U::virtual_ref_foo_ref_7_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&) const
-DEAL::X<0>& U::virtual_ref_foo_ref_8(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&, X<8>&)
-DEAL::X<0>& U::virtual_ref_foo_ref_8_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&, X<8>&) const
-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(X<1>)
-DEAL::const X<0>& U::const_ref_foo_1_const(X<1>) const
-DEAL::const X<0>& U::const_ref_foo_2(X<1>, X<2>)
-DEAL::const X<0>& U::const_ref_foo_2_const(X<1>, X<2>) const
-DEAL::const X<0>& U::const_ref_foo_3(X<1>, X<2>, X<3>)
-DEAL::const X<0>& U::const_ref_foo_3_const(X<1>, X<2>, X<3>) const
-DEAL::const X<0>& U::const_ref_foo_4(X<1>, X<2>, X<3>, X<4>)
-DEAL::const X<0>& U::const_ref_foo_4_const(X<1>, X<2>, X<3>, X<4>) const
-DEAL::const X<0>& U::const_ref_foo_5(X<1>, X<2>, X<3>, X<4>, X<5>)
-DEAL::const X<0>& U::const_ref_foo_5_const(X<1>, X<2>, X<3>, X<4>, X<5>) const
-DEAL::const X<0>& U::const_ref_foo_6(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>)
-DEAL::const X<0>& U::const_ref_foo_6_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>) const
-DEAL::const X<0>& U::const_ref_foo_7(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>)
-DEAL::const X<0>& U::const_ref_foo_7_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>) const
-DEAL::const X<0>& U::const_ref_foo_8(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>)
-DEAL::const X<0>& U::const_ref_foo_8_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>) const
-DEAL::const X<0>& U::const_ref_foo_const_ref_0()
-DEAL::const X<0>& U::const_ref_foo_const_ref_0_const() const
-DEAL::const X<0>& U::const_ref_foo_const_ref_1(X<1>&)
-DEAL::const X<0>& U::const_ref_foo_const_ref_1_const(X<1>&) const
-DEAL::const X<0>& U::const_ref_foo_const_ref_2(X<1>&, X<2>&)
-DEAL::const X<0>& U::const_ref_foo_const_ref_2_const(X<1>&, X<2>&) const
-DEAL::const X<0>& U::const_ref_foo_const_ref_3(X<1>&, X<2>&, X<3>&)
-DEAL::const X<0>& U::const_ref_foo_const_ref_3_const(X<1>&, X<2>&, X<3>&) const
-DEAL::const X<0>& U::const_ref_foo_const_ref_4(X<1>&, X<2>&, X<3>&, X<4>&)
-DEAL::const X<0>& U::const_ref_foo_const_ref_4_const(X<1>&, X<2>&, X<3>&, X<4>&) const
-DEAL::const X<0>& U::const_ref_foo_const_ref_5(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&)
-DEAL::const X<0>& U::const_ref_foo_const_ref_5_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&) const
-DEAL::const X<0>& U::const_ref_foo_const_ref_6(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&)
-DEAL::const X<0>& U::const_ref_foo_const_ref_6_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&) const
-DEAL::const X<0>& U::const_ref_foo_const_ref_7(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&)
-DEAL::const X<0>& U::const_ref_foo_const_ref_7_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&) const
-DEAL::const X<0>& U::const_ref_foo_const_ref_8(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&, X<8>&)
-DEAL::const X<0>& U::const_ref_foo_const_ref_8_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&, X<8>&) const
-DEAL::const X<0>& U::const_ref_foo_ref_0()
-DEAL::const X<0>& U::const_ref_foo_ref_0_const() const
-DEAL::const X<0>& U::const_ref_foo_ref_1(X<1>&)
-DEAL::const X<0>& U::const_ref_foo_ref_1_const(X<1>&) const
-DEAL::const X<0>& U::const_ref_foo_ref_2(X<1>&, X<2>&)
-DEAL::const X<0>& U::const_ref_foo_ref_2_const(X<1>&, X<2>&) const
-DEAL::const X<0>& U::const_ref_foo_ref_3(X<1>&, X<2>&, X<3>&)
-DEAL::const X<0>& U::const_ref_foo_ref_3_const(X<1>&, X<2>&, X<3>&) const
-DEAL::const X<0>& U::const_ref_foo_ref_4(X<1>&, X<2>&, X<3>&, X<4>&)
-DEAL::const X<0>& U::const_ref_foo_ref_4_const(X<1>&, X<2>&, X<3>&, X<4>&) const
-DEAL::const X<0>& U::const_ref_foo_ref_5(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&)
-DEAL::const X<0>& U::const_ref_foo_ref_5_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&) const
-DEAL::const X<0>& U::const_ref_foo_ref_6(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&)
-DEAL::const X<0>& U::const_ref_foo_ref_6_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&) const
-DEAL::const X<0>& U::const_ref_foo_ref_7(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&)
-DEAL::const X<0>& U::const_ref_foo_ref_7_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&) const
-DEAL::const X<0>& U::const_ref_foo_ref_8(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&, X<8>&)
-DEAL::const X<0>& U::const_ref_foo_ref_8_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&, X<8>&) const
-DEAL::const X<0>& U::virtual_const_ref_foo_0()
-DEAL::const X<0>& U::virtual_const_ref_foo_0_const() const
-DEAL::const X<0>& U::virtual_const_ref_foo_1(X<1>)
-DEAL::const X<0>& U::virtual_const_ref_foo_1_const(X<1>) const
-DEAL::const X<0>& U::virtual_const_ref_foo_2(X<1>, X<2>)
-DEAL::const X<0>& U::virtual_const_ref_foo_2_const(X<1>, X<2>) const
-DEAL::const X<0>& U::virtual_const_ref_foo_3(X<1>, X<2>, X<3>)
-DEAL::const X<0>& U::virtual_const_ref_foo_3_const(X<1>, X<2>, X<3>) const
-DEAL::const X<0>& U::virtual_const_ref_foo_4(X<1>, X<2>, X<3>, X<4>)
-DEAL::const X<0>& U::virtual_const_ref_foo_4_const(X<1>, X<2>, X<3>, X<4>) const
-DEAL::const X<0>& U::virtual_const_ref_foo_5(X<1>, X<2>, X<3>, X<4>, X<5>)
-DEAL::const X<0>& U::virtual_const_ref_foo_5_const(X<1>, X<2>, X<3>, X<4>, X<5>) const
-DEAL::const X<0>& U::virtual_const_ref_foo_6(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>)
-DEAL::const X<0>& U::virtual_const_ref_foo_6_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>) const
-DEAL::const X<0>& U::virtual_const_ref_foo_7(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>)
-DEAL::const X<0>& U::virtual_const_ref_foo_7_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>) const
-DEAL::const X<0>& U::virtual_const_ref_foo_8(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>)
-DEAL::const X<0>& U::virtual_const_ref_foo_8_const(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>) const
-DEAL::const X<0>& U::virtual_const_ref_foo_const_ref_0()
-DEAL::const X<0>& U::virtual_const_ref_foo_const_ref_0_const() const
-DEAL::const X<0>& U::virtual_const_ref_foo_const_ref_1(X<1>&)
-DEAL::const X<0>& U::virtual_const_ref_foo_const_ref_1_const(X<1>&) const
-DEAL::const X<0>& U::virtual_const_ref_foo_const_ref_2(X<1>&, X<2>&)
-DEAL::const X<0>& U::virtual_const_ref_foo_const_ref_2_const(X<1>&, X<2>&) const
-DEAL::const X<0>& U::virtual_const_ref_foo_const_ref_3(X<1>&, X<2>&, X<3>&)
-DEAL::const X<0>& U::virtual_const_ref_foo_const_ref_3_const(X<1>&, X<2>&, X<3>&) const
-DEAL::const X<0>& U::virtual_const_ref_foo_const_ref_4(X<1>&, X<2>&, X<3>&, X<4>&)
-DEAL::const X<0>& U::virtual_const_ref_foo_const_ref_4_const(X<1>&, X<2>&, X<3>&, X<4>&) const
-DEAL::const X<0>& U::virtual_const_ref_foo_const_ref_5(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&)
-DEAL::const X<0>& U::virtual_const_ref_foo_const_ref_5_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&) const
-DEAL::const X<0>& U::virtual_const_ref_foo_const_ref_6(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&)
-DEAL::const X<0>& U::virtual_const_ref_foo_const_ref_6_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&) const
-DEAL::const X<0>& U::virtual_const_ref_foo_const_ref_7(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&)
-DEAL::const X<0>& U::virtual_const_ref_foo_const_ref_7_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&) const
-DEAL::const X<0>& U::virtual_const_ref_foo_const_ref_8(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&, X<8>&)
-DEAL::const X<0>& U::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
-DEAL::const X<0>& U::virtual_const_ref_foo_ref_0()
-DEAL::const X<0>& U::virtual_const_ref_foo_ref_0_const() const
-DEAL::const X<0>& U::virtual_const_ref_foo_ref_1(X<1>&)
-DEAL::const X<0>& U::virtual_const_ref_foo_ref_1_const(X<1>&) const
-DEAL::const X<0>& U::virtual_const_ref_foo_ref_2(X<1>&, X<2>&)
-DEAL::const X<0>& U::virtual_const_ref_foo_ref_2_const(X<1>&, X<2>&) const
-DEAL::const X<0>& U::virtual_const_ref_foo_ref_3(X<1>&, X<2>&, X<3>&)
-DEAL::const X<0>& U::virtual_const_ref_foo_ref_3_const(X<1>&, X<2>&, X<3>&) const
-DEAL::const X<0>& U::virtual_const_ref_foo_ref_4(X<1>&, X<2>&, X<3>&, X<4>&)
-DEAL::const X<0>& U::virtual_const_ref_foo_ref_4_const(X<1>&, X<2>&, X<3>&, X<4>&) const
-DEAL::const X<0>& U::virtual_const_ref_foo_ref_5(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&)
-DEAL::const X<0>& U::virtual_const_ref_foo_ref_5_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&) const
-DEAL::const X<0>& U::virtual_const_ref_foo_ref_6(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&)
-DEAL::const X<0>& U::virtual_const_ref_foo_ref_6_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&) const
-DEAL::const X<0>& U::virtual_const_ref_foo_ref_7(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&)
-DEAL::const X<0>& U::virtual_const_ref_foo_ref_7_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&) const
-DEAL::const X<0>& U::virtual_const_ref_foo_ref_8(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&, X<8>&)
-DEAL::const X<0>& U::virtual_const_ref_foo_ref_8_const(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&, X<8>&) const
-DEAL::static X<0> U::static_foo_0()
-DEAL::static X<0> U::static_foo_1(X<1>)
-DEAL::static X<0> U::static_foo_2(X<1>, X<2>)
-DEAL::static X<0> U::static_foo_3(X<1>, X<2>, X<3>)
-DEAL::static X<0> U::static_foo_4(X<1>, X<2>, X<3>, X<4>)
-DEAL::static X<0> U::static_foo_5(X<1>, X<2>, X<3>, X<4>, X<5>)
-DEAL::static X<0> U::static_foo_6(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>)
-DEAL::static X<0> U::static_foo_7(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>)
-DEAL::static X<0> U::static_foo_8(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>)
-DEAL::static X<0> U::static_foo_const_ref_0()
-DEAL::static X<0> U::static_foo_const_ref_1(const X<1>&)
-DEAL::static X<0> U::static_foo_const_ref_2(const X<1>&, const X<2>&)
-DEAL::static X<0> U::static_foo_const_ref_3(const X<1>&, const X<2>&, const X<3>&)
-DEAL::static X<0> U::static_foo_const_ref_4(const X<1>&, const X<2>&, const X<3>&, const X<4>&)
-DEAL::static X<0> U::static_foo_const_ref_5(const X<1>&, const X<2>&, const X<3>&, const X<4>&, const X<5>&)
-DEAL::static X<0> U::static_foo_const_ref_6(const X<1>&, const X<2>&, const X<3>&, const X<4>&, const X<5>&, const X<6>&)
-DEAL::static X<0> U::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>&)
-DEAL::static X<0> U::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>&)
-DEAL::static X<0> U::static_foo_ref_0()
-DEAL::static X<0> U::static_foo_ref_1(X<1>&)
-DEAL::static X<0> U::static_foo_ref_2(X<1>&, X<2>&)
-DEAL::static X<0> U::static_foo_ref_3(X<1>&, X<2>&, X<3>&)
-DEAL::static X<0> U::static_foo_ref_4(X<1>&, X<2>&, X<3>&, X<4>&)
-DEAL::static X<0> U::static_foo_ref_5(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&)
-DEAL::static X<0> U::static_foo_ref_6(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&)
-DEAL::static X<0> U::static_foo_ref_7(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&)
-DEAL::static X<0> U::static_foo_ref_8(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&, X<8>&)
-DEAL::static X<0>& U::static_ref_foo_0()
-DEAL::static X<0>& U::static_ref_foo_1(X<1>)
-DEAL::static X<0>& U::static_ref_foo_2(X<1>, X<2>)
-DEAL::static X<0>& U::static_ref_foo_3(X<1>, X<2>, X<3>)
-DEAL::static X<0>& U::static_ref_foo_4(X<1>, X<2>, X<3>, X<4>)
-DEAL::static X<0>& U::static_ref_foo_5(X<1>, X<2>, X<3>, X<4>, X<5>)
-DEAL::static X<0>& U::static_ref_foo_6(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>)
-DEAL::static X<0>& U::static_ref_foo_7(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>)
-DEAL::static X<0>& U::static_ref_foo_8(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>)
-DEAL::static X<0>& U::static_ref_foo_const_ref_0()
-DEAL::static X<0>& U::static_ref_foo_const_ref_1(const X<1>&)
-DEAL::static X<0>& U::static_ref_foo_const_ref_2(const X<1>&, const X<2>&)
-DEAL::static X<0>& U::static_ref_foo_const_ref_3(const X<1>&, const X<2>&, const X<3>&)
-DEAL::static X<0>& U::static_ref_foo_const_ref_4(const X<1>&, const X<2>&, const X<3>&, const X<4>&)
-DEAL::static X<0>& U::static_ref_foo_const_ref_5(const X<1>&, const X<2>&, const X<3>&, const X<4>&, const X<5>&)
-DEAL::static X<0>& U::static_ref_foo_const_ref_6(const X<1>&, const X<2>&, const X<3>&, const X<4>&, const X<5>&, const X<6>&)
-DEAL::static X<0>& U::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>&)
-DEAL::static X<0>& U::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>&)
-DEAL::static X<0>& U::static_ref_foo_ref_0()
-DEAL::static X<0>& U::static_ref_foo_ref_1(X<1>&)
-DEAL::static X<0>& U::static_ref_foo_ref_2(X<1>&, X<2>&)
-DEAL::static X<0>& U::static_ref_foo_ref_3(X<1>&, X<2>&, X<3>&)
-DEAL::static X<0>& U::static_ref_foo_ref_4(X<1>&, X<2>&, X<3>&, X<4>&)
-DEAL::static X<0>& U::static_ref_foo_ref_5(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&)
-DEAL::static X<0>& U::static_ref_foo_ref_6(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&)
-DEAL::static X<0>& U::static_ref_foo_ref_7(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&)
-DEAL::static X<0>& U::static_ref_foo_ref_8(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&, X<8>&)
-DEAL::static const X<0>& U::static_const_ref_foo_0()
-DEAL::static const X<0>& U::static_const_ref_foo_1(X<1>)
-DEAL::static const X<0>& U::static_const_ref_foo_2(X<1>, X<2>)
-DEAL::static const X<0>& U::static_const_ref_foo_3(X<1>, X<2>, X<3>)
-DEAL::static const X<0>& U::static_const_ref_foo_4(X<1>, X<2>, X<3>, X<4>)
-DEAL::static const X<0>& U::static_const_ref_foo_5(X<1>, X<2>, X<3>, X<4>, X<5>)
-DEAL::static const X<0>& U::static_const_ref_foo_6(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>)
-DEAL::static const X<0>& U::static_const_ref_foo_7(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>)
-DEAL::static const X<0>& U::static_const_ref_foo_8(X<1>, X<2>, X<3>, X<4>, X<5>, X<6>, X<7>, X<8>)
-DEAL::static const X<0>& U::static_const_ref_foo_const_ref_0()
-DEAL::static const X<0>& U::static_const_ref_foo_const_ref_1(const X<1>&)
-DEAL::static const X<0>& U::static_const_ref_foo_const_ref_2(const X<1>&, const X<2>&)
-DEAL::static const X<0>& U::static_const_ref_foo_const_ref_3(const X<1>&, const X<2>&, const X<3>&)
-DEAL::static const X<0>& U::static_const_ref_foo_const_ref_4(const X<1>&, const X<2>&, const X<3>&, const X<4>&)
-DEAL::static const X<0>& U::static_const_ref_foo_const_ref_5(const X<1>&, const X<2>&, const X<3>&, const X<4>&, const X<5>&)
-DEAL::static const X<0>& U::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>&)
-DEAL::static const X<0>& U::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>&)
-DEAL::static const X<0>& U::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>&)
-DEAL::static const X<0>& U::static_const_ref_foo_ref_0()
-DEAL::static const X<0>& U::static_const_ref_foo_ref_1(X<1>&)
-DEAL::static const X<0>& U::static_const_ref_foo_ref_2(X<1>&, X<2>&)
-DEAL::static const X<0>& U::static_const_ref_foo_ref_3(X<1>&, X<2>&, X<3>&)
-DEAL::static const X<0>& U::static_const_ref_foo_ref_4(X<1>&, X<2>&, X<3>&, X<4>&)
-DEAL::static const X<0>& U::static_const_ref_foo_ref_5(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&)
-DEAL::static const X<0>& U::static_const_ref_foo_ref_6(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&)
-DEAL::static const X<0>& U::static_const_ref_foo_ref_7(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&)
-DEAL::static const X<0>& U::static_const_ref_foo_ref_8(X<1>&, X<2>&, X<3>&, X<4>&, X<5>&, X<6>&, X<7>&, X<8>&)
-