[PATCH v2 3/8] infcall, c++: collect more pass-by-reference information

[PATCH v2 3/8] infcall, c++: collect more pass-by-reference information

[Tankut Baris Aktemur]

Walk through a given type to collect information about whether the type
is copy constructible, destructible, trivially copyable, trivially copy
constructible, trivially destructible.  The previous algorithm returned
only a boolean result about whether the type is trivially copyable.
This patch computes more info.  Additionally, it utilizes DWARF attributes
that were previously not taken into account; namely,
DW_AT_deleted, DW_AT_defaulted, and DW_AT_calling_convention.

gdb/ChangeLog:

2019-MM-DD  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>

	* gnu-v3-abi.c (enum definition_style): New.
	(get_def_style): New.
	(is_user_provided_def): New.
	(is_implicit_def): New.
	(is_copy_or_move_constructor_type): New.
	(is_copy_constructor_type): New.
	(is_move_constructor_type): New.
	(gnuv3_pass_by_reference): Update.

2019-06-24  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>
---
 gdb/gnu-v3-abi.c | 275 ++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 223 insertions(+), 52 deletions(-)

diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c
index 69cd56859cb..ab3da51f78d 100644
--- a/gdb/gnu-v3-abi.c
+++ b/gdb/gnu-v3-abi.c
@@ -23,6 +23,7 @@
 #include "cp-abi.h"
 #include "cp-support.h"
 #include "demangle.h"
+#include "dwarf2.h"
 #include "objfiles.h"
 #include "valprint.h"
 #include "c-lang.h"
@@ -1228,6 +1229,124 @@ gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
   return real_stop_pc;
 }
 
+/* A member function is in one these states.  */
+
+enum definition_style
+{
+  DOES_NOT_EXIST_IN_SOURCE,
+  DEFAULTED_INSIDE,
+  DEFAULTED_OUTSIDE,
+  DELETED,
+  EXPLICIT,
+};
+
+/* Return how the given field is defined.  */
+
+static definition_style
+get_def_style (struct fn_field *fn, int fieldelem)
+{
+  if (TYPE_FN_FIELD_DELETED (fn, fieldelem))
+    return DELETED;
+
+  if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem))
+    return DOES_NOT_EXIST_IN_SOURCE;
+
+  switch (TYPE_FN_FIELD_DEFAULTED (fn, fieldelem))
+    {
+    case DW_DEFAULTED_no:
+      return EXPLICIT;
+    case DW_DEFAULTED_in_class:
+      return DEFAULTED_INSIDE;
+    case DW_DEFAULTED_out_of_class:
+      return DEFAULTED_OUTSIDE;
+    default:
+      break;
+    }
+
+  return EXPLICIT;
+}
+
+/* Helper functions to determine whether the given definition style
+   denotes that the definition is user-provided or implicit.
+   Being defaulted outside the class decl counts as an explicit
+   user-definition, while being defaulted inside is implicit.  */
+
+static bool
+is_user_provided_def (definition_style def)
+{
+  return def == EXPLICIT || def == DEFAULTED_OUTSIDE;
+}
+
+static bool
+is_implicit_def (definition_style def)
+{
+  return def == DOES_NOT_EXIST_IN_SOURCE || def == DEFAULTED_INSIDE;
+}
+
+/* Helper function to decide if METHOD_TYPE is a copy/move
+   constructor type for CLASS_TYPE.  EXPECTED is the expected
+   type code for the "right-hand-side" argument.
+   This function is supposed to be used by the IS_COPY_CONSTRUCTOR_TYPE
+   and IS_MOVE_CONSTRUCTOR_TYPE functions below.  Normally, you should
+   not need to call this directly.  */
+
+static bool
+is_copy_or_move_constructor_type (struct type *class_type,
+				  struct type *method_type,
+				  type_code expected)
+{
+  /* The method should take at least two arguments...  */
+  if (TYPE_NFIELDS (method_type) < 2)
+    return false;
+
+  /* ...and the second argument should be the same as the class
+     type, with the expected type code...  */
+  struct type *arg_type = TYPE_FIELD_TYPE (method_type, 1);
+
+  if (TYPE_CODE (arg_type) != expected)
+    return false;
+
+  struct type *target = check_typedef (TYPE_TARGET_TYPE (arg_type));
+  if (!(class_types_same_p (target, class_type)))
+    return false;
+
+  /* ...and if any of the remaining arguments don't have a default value
+     then this is not a copy or move constructor, but just a
+     constructor.  */
+  for (int i = 2; i < TYPE_NFIELDS (method_type); i++)
+    {
+      arg_type = TYPE_FIELD_TYPE (method_type, i);
+      /* FIXME taktemur/2019-04-23: As of this date, neither
+	 clang++-7.0.0 nor g++-8.2.0 produce a DW_AT_default_value
+	 attribute.  GDB is also not set to read this attribute, yet.
+	 Hence, we immediately return false if there are more than
+	 2 parameters.  */
+      return false;
+    }
+
+  return true;
+}
+
+/* Return true if METHOD_TYPE is a copy ctor type for CLASS_TYPE.  */
+
+static bool
+is_copy_constructor_type (struct type *class_type,
+			  struct type *method_type)
+{
+  return is_copy_or_move_constructor_type (class_type, method_type,
+					   TYPE_CODE_REF);
+}
+
+/* Return true if METHOD_TYPE is a move ctor type for CLASS_TYPE.  */
+
+static bool
+is_move_constructor_type (struct type *class_type,
+			  struct type *method_type)
+{
+  return is_copy_or_move_constructor_type (class_type, method_type,
+					   TYPE_CODE_RVALUE_REF);
+}
+
 /* Return pass-by-reference information for the given TYPE.
 
    The rule in the v3 ABI document comes from section 3.1.1.  If the
@@ -1236,16 +1355,15 @@ gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
    is one or perform the copy itself otherwise), pass the address of
    the copy, and then destroy the temporary (if necessary).
 
-   For return values with non-trivial copy constructors or
+   For return values with non-trivial copy/move constructors or
    destructors, space will be allocated in the caller, and a pointer
    will be passed as the first argument (preceding "this").
 
    We don't have a bulletproof mechanism for determining whether a
-   constructor or destructor is trivial.  For GCC and DWARF2 debug
-   information, we can check the artificial flag.
-
-   We don't do anything with the constructors or destructors,
-   but we have to get the argument passing right anyway.  */
+   constructor or destructor is trivial.  For GCC and DWARF5 debug
+   information, we can check the calling_convention attribute,
+   the 'artificial' flag, the 'defaulted' attribute, and the
+   'deleted' attribute.  */
 
 static struct language_pass_by_ref_info
 gnuv3_pass_by_reference (struct type *type)
@@ -1258,22 +1376,46 @@ gnuv3_pass_by_reference (struct type *type)
   struct language_pass_by_ref_info info
     = default_pass_by_reference (type);
 
-  /* FIXME: Currently, this implementation only fills in the
-     'trivially-copyable' field to perserve GDB's existing behavior.  */
+  bool has_cc_attr = false;
+  bool is_pass_by_value = false;
+  bool is_dynamic = false;
+  definition_style cctor_def = DOES_NOT_EXIST_IN_SOURCE;
+  definition_style dtor_def = DOES_NOT_EXIST_IN_SOURCE;
+  definition_style mctor_def = DOES_NOT_EXIST_IN_SOURCE;
 
   /* We're only interested in things that can have methods.  */
   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
       && TYPE_CODE (type) != TYPE_CODE_UNION)
     return info;
 
-  /* A dynamic class has a non-trivial copy constructor.
-     See c++98 section 12.8 Copying class objects [class.copy].  */
-  if (gnuv3_dynamic_class (type))
+  /* The compiler may have emitted the calling convention attribute.  */
+  if (TYPE_CPLUS_CALLING_CONVENTION (type) == DW_CC_pass_by_value)
     {
-      info.trivially_copyable = false;
-      return info;
+      has_cc_attr = true;
+      is_pass_by_value = true;
+      /* Do not return immediately.  We have to find out if this type
+	 is copy_constructible and destructible.  */
     }
 
+  if (TYPE_CPLUS_CALLING_CONVENTION (type) == DW_CC_pass_by_reference)
+    {
+      has_cc_attr = true;
+      is_pass_by_value = false;
+    }
+
+  /* A dynamic class has a non-trivial copy constructor.
+     See c++98 section 12.8 Copying class objects [class.copy].  */
+  if (gnuv3_dynamic_class (type))
+    is_dynamic = true;
+
+  /* FIXME taktemur/2019-04-23: What if there are multiple copy ctors?
+     E.g.:
+       class C {
+       public:
+	 C (C &c) { ... }
+	 C (const C &c) { ... }
+       };
+  */
   for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
     for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
 	 fieldelem++)
@@ -1282,49 +1424,58 @@ gnuv3_pass_by_reference (struct type *type)
 	const char *name = TYPE_FN_FIELDLIST_NAME (type, fieldnum);
 	struct type *fieldtype = TYPE_FN_FIELD_TYPE (fn, fieldelem);
 
-	/* If this function is marked as artificial, it is compiler-generated,
-	   and we assume it is trivial.  */
-	if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem))
-	  continue;
-
-	/* If we've found a destructor, we must pass this by reference.  */
 	if (name[0] == '~')
 	  {
-	    info.trivially_copyable = false;
-	    return info;
+	    /* We've found a destructor.
+	       There should be at most one dtor definition.  */
+	    gdb_assert (dtor_def == DOES_NOT_EXIST_IN_SOURCE);
+	    dtor_def = get_def_style (fn, fieldelem);
+	    info.dtor_name = TYPE_FN_FIELD_PHYSNAME (fn, fieldelem);
 	  }
-
-	/* If the mangled name of this method doesn't indicate that it
-	   is a constructor, we're not interested.
-
-	   FIXME drow/2007-09-23: We could do this using the name of
-	   the method and the name of the class instead of dealing
-	   with the mangled name.  We don't have a convenient function
-	   to strip off both leading scope qualifiers and trailing
-	   template arguments yet.  */
-	if (!is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn, fieldelem))
-	    && !TYPE_FN_FIELD_CONSTRUCTOR (fn, fieldelem))
-	  continue;
-
-	/* If this method takes two arguments, and the second argument is
-	   a reference to this class, then it is a copy constructor.  */
-	if (TYPE_NFIELDS (fieldtype) == 2)
+	else if (is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn, fieldelem))
+		 || TYPE_FN_FIELD_CONSTRUCTOR (fn, fieldelem))
 	  {
-	    struct type *arg_type = TYPE_FIELD_TYPE (fieldtype, 1);
-
-	    if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
+	    /* FIXME drow/2007-09-23: We could do this using the name of
+	       the method and the name of the class instead of dealing
+	       with the mangled name.  We don't have a convenient function
+	       to strip off both leading scope qualifiers and trailing
+	       template arguments yet.  */
+	    if (is_copy_constructor_type (type, fieldtype))
 	      {
-		struct type *arg_target_type
-		  = check_typedef (TYPE_TARGET_TYPE (arg_type));
-		if (class_types_same_p (arg_target_type, type))
-		  {
-		    info.trivially_copyable = false;
-		    return info;
-		  }
+		/* It's unclear how to handle multiple copy ctors.
+		   Until we figure that out, enforce a single def.  */
+		gdb_assert (cctor_def == DOES_NOT_EXIST_IN_SOURCE);
+		cctor_def = get_def_style (fn, fieldelem);
+		info.cctor_name = TYPE_FN_FIELD_PHYSNAME (fn, fieldelem);
 	      }
+	    else if (is_move_constructor_type (type, fieldtype))
+	      mctor_def = get_def_style (fn, fieldelem);
 	  }
       }
 
+  bool cctor_implicitly_deleted
+    = (mctor_def != DOES_NOT_EXIST_IN_SOURCE
+       && cctor_def == DOES_NOT_EXIST_IN_SOURCE);
+
+  bool cctor_explicitly_deleted = (cctor_def == DELETED);
+
+  if (cctor_implicitly_deleted || cctor_explicitly_deleted)
+    info.copy_constructible = false;
+
+  if (dtor_def == DELETED)
+    info.destructible = false;
+
+  info.trivially_destructible = is_implicit_def (dtor_def);
+
+  info.trivially_copy_constructible
+    = (is_implicit_def (cctor_def)
+       && !is_dynamic);
+
+  info.trivially_copyable
+    = (info.trivially_copy_constructible
+       && info.trivially_destructible
+       && !is_user_provided_def (mctor_def));
+
   /* Even if all the constructors and destructors were artificial, one
      of them may have invoked a non-artificial constructor or
      destructor in a base class.  If any base class needs to be passed
@@ -1335,15 +1486,35 @@ gnuv3_pass_by_reference (struct type *type)
   for (fieldnum = 0; fieldnum < TYPE_NFIELDS (type); fieldnum++)
     if (!field_is_static (&TYPE_FIELD (type, fieldnum)))
       {
+	struct type *field_type = TYPE_FIELD_TYPE (type, fieldnum);
+
+	/* For arrays, make the decision based on the element type.  */
+	if (TYPE_CODE (field_type) == TYPE_CODE_ARRAY)
+	  field_type = field_type->main_type->target_type;
+
 	struct language_pass_by_ref_info field_info
-	  = gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type, fieldnum));
+	  = gnuv3_pass_by_reference (field_type);
+
+	if (!field_info.copy_constructible)
+	  info.copy_constructible = false;
+	if (!field_info.destructible)
+	  info.destructible = false;
 	if (!field_info.trivially_copyable)
-	  {
-	    info.trivially_copyable = false;
-	    return info;
-	  }
+	  info.trivially_copyable = false;
+	if (!field_info.trivially_copy_constructible)
+	  info.trivially_copy_constructible = false;
+	if (!field_info.trivially_destructible)
+	  info.trivially_destructible = false;
       }
 
+  /* Consistency check.  */
+  if (has_cc_attr && info.trivially_copyable != is_pass_by_value)
+    {
+      /* DWARF CC attribute is not the same as the inferred value;
+	 use the DWARF attribute.  */
+      info.trivially_copyable = is_pass_by_value;
+    }
+
   return info;
 }
 
-- 
2.17.1

[PATCH v2 7/8] infcall: handle pass-by-reference arguments appropriately

[Tankut Baris Aktemur]

If an aggregate argument is implicitly pass-by-reference, allocate
a temporary object on the stack, initialize it via the copy constructor
(if exists) or trivially by memcpy'ing.  Pass the reference of the
temporary to the callee function.  After the callee returns, invoke
the destructor of the temporary.

gdb/ChangeLog:

2019-MM-DD  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>

	* infcall.c (call_function_by_hand_dummy): Update.
	(struct destructor_info): New struct.
	(call_destructors): New auxiliary function.

2019-06-24  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>
---
 gdb/infcall.c | 103 ++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 100 insertions(+), 3 deletions(-)

diff --git a/gdb/infcall.c b/gdb/infcall.c
index e81df995ff5..0c94d8a3d25 100644
--- a/gdb/infcall.c
+++ b/gdb/infcall.c
@@ -42,6 +42,7 @@
 #include "thread-fsm.h"
 #include <algorithm>
 #include "common/scope-exit.h"
+#include <list>
 
 /* If we can't find a function's name from its address,
    we print this instead.  */
@@ -704,6 +705,33 @@ reserve_stack_space (const type *values_type, CORE_ADDR &sp)
   return addr;
 }
 
+/* The data structure which keeps a destructor function and
+   its implicit 'this' parameter.  */
+
+struct destructor_info
+{
+  destructor_info (struct value *function, struct value *self)
+    : function (function), self (self) { }
+
+  struct value *function;
+  struct value *self;
+};
+
+
+/* Auxiliary function that takes a list of destructor functions
+   with their 'this' parameters, and invokes the functions.  */
+
+static void
+call_destructors (const std::list<destructor_info> &dtors_to_invoke,
+		  struct type *default_return_type)
+{
+  for (auto vals : dtors_to_invoke)
+    {
+      call_function_by_hand (vals.function, default_return_type,
+			     gdb::make_array_view (&(vals.self), 1));
+    }
+}
+
 /* See infcall.h.  */
 
 struct value *
@@ -983,6 +1011,12 @@ call_function_by_hand_dummy (struct value *function,
       internal_error (__FILE__, __LINE__, _("bad switch"));
     }
 
+  /* Coerce the arguments and handle pass-by-reference.
+     We want to remember the destruction required for pass-by-ref values.
+     For these, store the dtor function and the 'this' argument
+     in DTORS_TO_INVOKE.  */
+  std::list<destructor_info> dtors_to_invoke;
+
   for (int i = args.size () - 1; i >= 0; i--)
     {
       int prototyped;
@@ -1020,9 +1054,68 @@ call_function_by_hand_dummy (struct value *function,
       args[i] = value_arg_coerce (gdbarch, args[i],
 				  param_type, prototyped);
 
-      if (param_type != NULL
-	  && !(language_pass_by_reference (param_type).trivially_copyable))
-	args[i] = value_addr (args[i]);
+      if (param_type == NULL)
+	continue;
+
+      auto info = language_pass_by_reference (param_type);
+      if (!info.copy_constructible)
+	error (_("expression cannot be evaluated because the type '%s' "
+		 "is not copy constructible"), TYPE_NAME (param_type));
+
+      if (!info.destructible)
+	error (_("expression cannot be evaluated because the type '%s' "
+		 "is not destructible"), TYPE_NAME (param_type));
+
+      if (info.trivially_copyable)
+	continue;
+
+      /* This is a pass-by-ref value.  Check for error cases before
+	 pushing the temporary to the stack.  */
+
+      if (!info.trivially_copy_constructible && info.cctor_name == NULL)
+	error (_("evaluation of this expression requires a copy constructor"
+		 " for the type '%s'."), TYPE_NAME (param_type));
+
+      if (!info.trivially_destructible && info.dtor_name == NULL)
+	error (_("evaluation of this expression requires a destructor"
+		 " for the type '%s'."), TYPE_NAME (param_type));
+
+      /* Make a copy of the argument on the stack.  If the argument is
+	 trivially copy ctor'able, copy bit by bit.  Otherwise, call
+	 the copy ctor to initialize the clone.  */
+      CORE_ADDR addr = reserve_stack_space (param_type, sp);
+      struct value *clone
+	= value_from_contents_and_address (param_type, NULL, addr);
+      push_thread_stack_temporary (call_thread.get (), clone);
+      struct value *clone_ptr
+	= value_from_pointer (lookup_pointer_type (param_type), addr);
+
+      if (info.trivially_copy_constructible)
+	{
+	  int length = TYPE_LENGTH (param_type);
+	  write_memory (addr, value_contents (args[i]), length);
+	}
+      else
+	{
+	  struct value *copy_ctor
+	    = find_function_in_inferior (info.cctor_name, 0);
+	  struct value *cctor_args[2] = { clone_ptr, args[i] };
+	  call_function_by_hand (copy_ctor, default_return_type,
+				 gdb::make_array_view (cctor_args, 2));
+	}
+
+      /* If the argument has a destructor, remember it so that we
+	 invoke it after the infcall is complete.  */
+      if (!info.trivially_destructible)
+	{
+	  struct value *dtor
+	    = find_function_in_inferior (info.dtor_name, 0);
+	  /* Insert the dtor to the front of the list to call them
+	     in reverse order later.  */
+	  dtors_to_invoke.emplace_front (dtor, clone_ptr);
+	}
+
+      args[i] = clone_ptr;
     }
 
   /* Reserve space for the return structure to be written on the
@@ -1189,6 +1282,10 @@ call_function_by_hand_dummy (struct value *function,
 	    maybe_remove_breakpoints ();
 
 	    gdb_assert (retval != NULL);
+
+	    /* Destruct the pass-by-ref argument clones.  */
+	    call_destructors (dtors_to_invoke, default_return_type);
+
 	    return retval;
 	  }
 
-- 
2.17.1

[PATCH v2 5/8] infcall: move assertions in 'call_function_by_hand_dummy' to an earlier spot

[Tankut Baris Aktemur]

This is a refactoring that performs type assertions on the callee
function at the beginning of 'call_function_by_hand_dummy' rather
than at a later point.

gdb/ChangeLog:

2019-MM-DD  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>

	* infcall.c (call_function_by_hand_dummy): Refactor.

2019-06-24  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>
---
 gdb/infcall.c | 41 +++++++++++++++++++++--------------------
 1 file changed, 21 insertions(+), 20 deletions(-)

diff --git a/gdb/infcall.c b/gdb/infcall.c
index ea96f887c8b..f3e244620e8 100644
--- a/gdb/infcall.c
+++ b/gdb/infcall.c
@@ -782,6 +782,27 @@ call_function_by_hand_dummy (struct value *function,
   if (!gdbarch_push_dummy_call_p (gdbarch))
     error (_("This target does not support function calls."));
 
+  /* Find the function type and do a sanity check.  */
+  type *ftype;
+  type *values_type;
+  CORE_ADDR funaddr = find_function_addr (function, &values_type, &ftype);
+
+  if (values_type == NULL)
+    values_type = default_return_type;
+  if (values_type == NULL)
+    {
+      const char *name = get_function_name (funaddr,
+					    name_buf, sizeof (name_buf));
+      error (_("'%s' has unknown return type; "
+	       "cast the call to its declared return type"),
+	     name);
+    }
+
+  values_type = check_typedef (values_type);
+
+  if (args.size () < TYPE_NFIELDS (ftype))
+    error (_("Too few arguments in function call."));
+
   /* A holder for the inferior status.
      This is only needed while we're preparing the inferior function call.  */
   infcall_control_state_up inf_status (save_infcall_control_state ());
@@ -887,23 +908,6 @@ call_function_by_hand_dummy (struct value *function,
       }
   }
 
-  type *ftype;
-  type *values_type;
-  CORE_ADDR funaddr = find_function_addr (function, &values_type, &ftype);
-
-  if (values_type == NULL)
-    values_type = default_return_type;
-  if (values_type == NULL)
-    {
-      const char *name = get_function_name (funaddr,
-					    name_buf, sizeof (name_buf));
-      error (_("'%s' has unknown return type; "
-	       "cast the call to its declared return type"),
-	     name);
-    }
-
-  values_type = check_typedef (values_type);
-
   /* Are we returning a value using a structure return?  */
 
   if (gdbarch_return_in_first_hidden_param_p (gdbarch, values_type))
@@ -981,9 +985,6 @@ call_function_by_hand_dummy (struct value *function,
       internal_error (__FILE__, __LINE__, _("bad switch"));
     }
 
-  if (args.size () < TYPE_NFIELDS (ftype))
-    error (_("Too few arguments in function call."));
-
   for (int i = args.size () - 1; i >= 0; i--)
     {
       int prototyped;
-- 
2.17.1

[PATCH v2 8/8] testsuite, cp: increase the coverage of testing pass-by-ref arguments

[Tankut Baris Aktemur]

Extend testcases for GDB's infcall of call-by-value functions that take
aggregate values as parameters.  In particular, existing test has been
substantially extended with class definitions whose definitions of
copy constructor, destructor, and move constructor functions
are a combination of
(1) explicitly defined by the user,
(2) defaulted inside the class declaration,
(3) defaulted outside the class declaration,
(4) deleted
(5) not defined in the source.

For each combination, a small and a large class is generated
as well as a derived class and a container class.  Additionally,
the following manually-written cases are provided:
- a dynamic class (i.e. class with a virtual method)
- classes that contain an array field
- a class whose copy ctor is inlined
- a class whose destructor is deleted

Test cases check whether GDB makes the right decision to pass an object
by value or implicitly by reference, whether really a copy of the
argument is passed, and whether the copy constructor and destructor
of the clone of the argument are invoked properly.

The input program pass-by-ref.cc is generated.  By means of a flag
inside the test file, the program can be re-generated.
The input program pass-by-ref-2.cc is manually-written.

Tests have been verified on the X86_64 architecture with
GCC 7.4.0 and 8.2.0.

gdb/testsuite/ChangeLog:

2019-MM-DD  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>

	* gdb.cp/pass-by-ref.cc: Extend with more cases (generated).
	* gdb.cp/pass-by-ref.exp: Extend with more cases.
	* gdb.cp/pass-by-ref-2.cc: New file.
	* gdb.cp/pass-by-ref-2.exp: New file.

2019-06-24  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>
---
 gdb/testsuite/gdb.cp/pass-by-ref-2.cc  |  179 +
 gdb/testsuite/gdb.cp/pass-by-ref-2.exp |   85 +
 gdb/testsuite/gdb.cp/pass-by-ref.cc    | 7368 +++++++++++++++++++++++-
 gdb/testsuite/gdb.cp/pass-by-ref.exp   |  412 +-
 4 files changed, 8007 insertions(+), 37 deletions(-)
 create mode 100644 gdb/testsuite/gdb.cp/pass-by-ref-2.cc
 create mode 100644 gdb/testsuite/gdb.cp/pass-by-ref-2.exp

diff --git a/gdb/testsuite/gdb.cp/pass-by-ref-2.cc b/gdb/testsuite/gdb.cp/pass-by-ref-2.cc
new file mode 100644
index 00000000000..20b055ce08a
--- /dev/null
+++ b/gdb/testsuite/gdb.cp/pass-by-ref-2.cc
@@ -0,0 +1,179 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 2019 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+class ByVal {
+public:
+  ByVal (void);
+
+  int x;
+};
+
+ByVal::ByVal (void)
+{
+  x = 2;
+}
+
+class ByRef {
+public:
+  ByRef (void);
+
+  ByRef (const ByRef &rhs);
+
+  int x;
+};
+
+ByRef::ByRef (void)
+{
+  x = 2;
+}
+
+ByRef::ByRef (const ByRef &rhs)
+{
+  x = 3; /* ByRef-cctor */
+}
+
+class ArrayContainerByVal {
+public:
+  ByVal items[2];
+};
+
+int
+cbvArrayContainerByVal (ArrayContainerByVal arg)
+{
+  arg.items[0].x += 4;  // intentionally modify
+  return arg.items[0].x;
+}
+
+class ArrayContainerByRef {
+public:
+  ByRef items[2];
+};
+
+int
+cbvArrayContainerByRef (ArrayContainerByRef arg)
+{
+  arg.items[0].x += 4;  // intentionally modify
+  return arg.items[0].x;
+}
+
+class DynamicBase {
+public:
+  DynamicBase (void);
+
+  virtual int get (void);
+
+  int x;
+};
+
+DynamicBase::DynamicBase (void)
+{
+  x = 2;
+}
+
+int
+DynamicBase::get (void)
+{
+  return 42;
+}
+
+class Dynamic : public DynamicBase {
+public:
+  virtual int get (void);
+};
+
+int
+Dynamic::get (void)
+{
+  return 9999;
+}
+
+int
+cbvDynamic (DynamicBase arg)
+{
+  arg.x += 4;  // intentionally modify
+  return arg.x + arg.get ();
+}
+
+class Inlined {
+public:
+  Inlined (void);
+
+  __attribute__((always_inline))
+  Inlined (const Inlined &rhs)
+  {
+    x = 3;
+  }
+
+  int x;
+};
+
+Inlined::Inlined (void)
+{
+  x = 2;
+}
+
+int
+cbvInlined (Inlined arg)
+{
+  arg.x += 4;  // intentionally modify
+  return arg.x;
+}
+
+class DtorDel {
+public:
+  DtorDel (void);
+
+  ~DtorDel (void) = delete;
+
+  int x;
+};
+
+DtorDel::DtorDel (void)
+{
+  x = 2;
+}
+
+int
+cbvDtorDel (DtorDel arg)
+{
+  // Calling this method should be rejected
+  return arg.x;
+}
+
+ArrayContainerByVal arrayContainerByVal;
+ArrayContainerByRef arrayContainerByRef;
+Dynamic dynamic;
+Inlined inlined;
+// Cannot stack-allocate DtorDel
+DtorDel *dtorDel;
+
+int
+main (void)
+{
+  int v;
+  dtorDel = new DtorDel;
+  /* Explicitly call the cbv function to make sure the compiler
+     will not omit any code in the binary.  */
+  v = cbvArrayContainerByVal (arrayContainerByVal);
+  v = cbvArrayContainerByRef (arrayContainerByRef);
+  v = cbvDynamic (dynamic);
+  v = cbvInlined (inlined);
+
+  /* stop here */
+
+  return 0;
+}
diff --git a/gdb/testsuite/gdb.cp/pass-by-ref-2.exp b/gdb/testsuite/gdb.cp/pass-by-ref-2.exp
new file mode 100644
index 00000000000..b02b0d9786a
--- /dev/null
+++ b/gdb/testsuite/gdb.cp/pass-by-ref-2.exp
@@ -0,0 +1,85 @@
+# Copyright 2019 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Check that GDB can call C++ functions whose parameters have
+# object type, and are either passed by value or implicitly by reference.
+#
+# This is a companion test to pass-by-ref.exp.  In this test, the input
+# is manually-written.  In pass-by-ref.exp, the test input is generated.
+#
+# We include tests for classes that
+# - contain arrays as fields,
+# - are dynamic (i.e. have virtual methods)
+# - have inlined copy ctor
+# - have deleted destructor
+
+if {[skip_cplus_tests]} {
+    untested "c++ test skipped"
+    continue
+}
+
+standard_testfile .cc
+
+set options {debug c++ additional_flags=-std=c++11}
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile $options]} {
+    return -1
+}
+
+if {![runto_main]} {
+    untested "failed to run to main"
+    return -1
+}
+
+set bp_location [gdb_get_line_number "stop here"]
+gdb_breakpoint $bp_location
+gdb_continue_to_breakpoint "end of main" ".*return .*;"
+
+gdb_test "print cbvArrayContainerByVal (arrayContainerByVal)" " = 6" \
+    "call cbvArrayContainerByVal"
+gdb_test "print arrayContainerByVal.items\[0\].x" " = 2" \
+    "cbv argument 'arrayContainerByVal' should not change"
+
+gdb_test "print cbvArrayContainerByRef (arrayContainerByRef)" " = 7" \
+    "call cbvArrayContainerByRef"
+gdb_test "print arrayContainerByRef.items\[0\].x" " = 2" \
+    "cbv argument 'arrayContainerByRef' should not change"
+
+gdb_test "print cbvDynamic (dynamic)" " = 48" \
+    "call cbvDynamic"
+gdb_test "print dynamic.x" " = 2" \
+    "cbv argument 'dynamic' should not change"
+
+set sig "\"Inlined\:\:Inlined\\(.*Inlined const\&\\)\""
+gdb_test "print cbvInlined (inlined)" \
+    "evaluation .* requires .* function $sig." \
+    "copy constructor not available"
+
+gdb_test "print cbvDtorDel (*dtorDel)" \
+    ".* cannot be evaluated .* 'DtorDel' is not destructible" \
+    "type not destructible"
+
+# Test that we get a breakpoint from the cctor during infcall and
+# we can examine arguments.  This is a test that the dummy frame
+# of the copy constructor is set up correctly by the infcall mechanism.
+set bp_location [gdb_get_line_number "ByRef-cctor"]
+gdb_breakpoint $bp_location
+gdb_test "print cbvArrayContainerByRef (arrayContainerByRef)" \
+    ".*The program being debugged stopped.*" \
+    "call cbvArrayContainerByRef with BP"
+gdb_test "backtrace" [multi_line \
+    "#0  ByRef\:\:ByRef .* at .*$srcfile:$bp_location" \
+    "#1  .* ArrayContainerByRef::ArrayContainerByRef .*" \
+    "#2  <function called from gdb>" \
+    "#3  main.*"]
diff --git a/gdb/testsuite/gdb.cp/pass-by-ref.cc b/gdb/testsuite/gdb.cp/pass-by-ref.cc
index bbe450a0f71..efad178d574 100644
--- a/gdb/testsuite/gdb.cp/pass-by-ref.cc
+++ b/gdb/testsuite/gdb.cp/pass-by-ref.cc
@@ -15,65 +15,7373 @@
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
-class Obj {
+/*** THIS FILE IS GENERATED BY THE TEST.  ***/
+/* If you regenerate, auto-indent and delete-trailing-whitespace
+   before committing.  */
+
+static int tracer = 0;
+
+/* The call-by-value function.  */
+template <class T>
+int
+cbv (T arg)
+{
+  arg.data[0] += 4; // intentionally modify the arg
+  return arg.data[0];
+}
+
+template <class T>
+int
+cbv_container (T arg)
+{
+  arg.item.data[0] += 4;  // intentionally modify
+  return arg.item.data[0];
+}
+
+
+/*** C++ class Small_absent_absent_absent ***/
+class Small_absent_absent_absent {
+public:
+  Small_absent_absent_absent (void);
+
+
+  int data[2];
+};
+
+Small_absent_absent_absent::Small_absent_absent_absent (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+
+
+Small_absent_absent_absent Small_absent_absent_absent_var; /* global var */
+
+template int cbv<Small_absent_absent_absent> (Small_absent_absent_absent arg);
+/*** C++ class Large_absent_absent_absent ***/
+class Large_absent_absent_absent {
+public:
+  Large_absent_absent_absent (void);
+
+
+  int data[150];
+};
+
+Large_absent_absent_absent::Large_absent_absent_absent (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+
+
+Large_absent_absent_absent Large_absent_absent_absent_var; /* global var */
+
+template int cbv<Large_absent_absent_absent> (Large_absent_absent_absent arg);
+/*** Class derived from Small_absent_absent_absent ***/
+class Derived_absent_absent_absent : public Small_absent_absent_absent {
+public:
+};
+
+Derived_absent_absent_absent Derived_absent_absent_absent_var; /* global var */
+
+template int cbv<Derived_absent_absent_absent> (Derived_absent_absent_absent arg);
+/*** Class that contains Small_absent_absent_absent ***/
+class Container_absent_absent_absent {
+public:
+  Small_absent_absent_absent item;
+};
+
+Container_absent_absent_absent Container_absent_absent_absent_var; /* global var */
+
+template int cbv_container<Container_absent_absent_absent> (Container_absent_absent_absent arg);
+/*** C++ class Small_absent_absent_explicit ***/
+class Small_absent_absent_explicit {
+public:
+  Small_absent_absent_explicit (void);
+  Small_absent_absent_explicit (Small_absent_absent_explicit &&rhs);
+
+
+  int data[2];
+};
+
+Small_absent_absent_explicit::Small_absent_absent_explicit (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_absent_absent_explicit::Small_absent_absent_explicit (Small_absent_absent_explicit &&rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_absent_absent_explicit Small_absent_absent_explicit_var; /* global var */
+
+template int cbv<Small_absent_absent_explicit> (Small_absent_absent_explicit arg);
+/*** C++ class Large_absent_absent_explicit ***/
+class Large_absent_absent_explicit {
+public:
+  Large_absent_absent_explicit (void);
+  Large_absent_absent_explicit (Large_absent_absent_explicit &&rhs);
+
+
+  int data[150];
+};
+
+Large_absent_absent_explicit::Large_absent_absent_explicit (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_absent_absent_explicit::Large_absent_absent_explicit (Large_absent_absent_explicit &&rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_absent_absent_explicit Large_absent_absent_explicit_var; /* global var */
+
+template int cbv<Large_absent_absent_explicit> (Large_absent_absent_explicit arg);
+/*** Class derived from Small_absent_absent_explicit ***/
+class Derived_absent_absent_explicit : public Small_absent_absent_explicit {
+public:
+};
+
+Derived_absent_absent_explicit Derived_absent_absent_explicit_var; /* global var */
+
+template int cbv<Derived_absent_absent_explicit> (Derived_absent_absent_explicit arg);
+/*** Class that contains Small_absent_absent_explicit ***/
+class Container_absent_absent_explicit {
+public:
+  Small_absent_absent_explicit item;
+};
+
+Container_absent_absent_explicit Container_absent_absent_explicit_var; /* global var */
+
+template int cbv_container<Container_absent_absent_explicit> (Container_absent_absent_explicit arg);
+/*** C++ class Small_absent_absent_defaultedIn ***/
+class Small_absent_absent_defaultedIn {
+public:
+  Small_absent_absent_defaultedIn (void);
+  Small_absent_absent_defaultedIn (Small_absent_absent_defaultedIn &&rhs) = default;
+
+
+  int data[2];
+};
+
+Small_absent_absent_defaultedIn::Small_absent_absent_defaultedIn (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+
+
+Small_absent_absent_defaultedIn Small_absent_absent_defaultedIn_var; /* global var */
+
+template int cbv<Small_absent_absent_defaultedIn> (Small_absent_absent_defaultedIn arg);
+/*** C++ class Large_absent_absent_defaultedIn ***/
+class Large_absent_absent_defaultedIn {
+public:
+  Large_absent_absent_defaultedIn (void);
+  Large_absent_absent_defaultedIn (Large_absent_absent_defaultedIn &&rhs) = default;
+
+
+  int data[150];
+};
+
+Large_absent_absent_defaultedIn::Large_absent_absent_defaultedIn (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+
+
+Large_absent_absent_defaultedIn Large_absent_absent_defaultedIn_var; /* global var */
+
+template int cbv<Large_absent_absent_defaultedIn> (Large_absent_absent_defaultedIn arg);
+/*** Class derived from Small_absent_absent_defaultedIn ***/
+class Derived_absent_absent_defaultedIn : public Small_absent_absent_defaultedIn {
+public:
+};
+
+Derived_absent_absent_defaultedIn Derived_absent_absent_defaultedIn_var; /* global var */
+
+template int cbv<Derived_absent_absent_defaultedIn> (Derived_absent_absent_defaultedIn arg);
+/*** Class that contains Small_absent_absent_defaultedIn ***/
+class Container_absent_absent_defaultedIn {
+public:
+  Small_absent_absent_defaultedIn item;
+};
+
+Container_absent_absent_defaultedIn Container_absent_absent_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_absent_absent_defaultedIn> (Container_absent_absent_defaultedIn arg);
+/*** C++ class Small_absent_absent_defaultedOut ***/
+class Small_absent_absent_defaultedOut {
+public:
+  Small_absent_absent_defaultedOut (void);
+  Small_absent_absent_defaultedOut (Small_absent_absent_defaultedOut &&rhs);
+
+
+  int data[2];
+};
+
+Small_absent_absent_defaultedOut::Small_absent_absent_defaultedOut (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_absent_absent_defaultedOut::Small_absent_absent_defaultedOut (Small_absent_absent_defaultedOut &&rhs) = default;
+
+
+Small_absent_absent_defaultedOut Small_absent_absent_defaultedOut_var; /* global var */
+
+template int cbv<Small_absent_absent_defaultedOut> (Small_absent_absent_defaultedOut arg);
+/*** C++ class Large_absent_absent_defaultedOut ***/
+class Large_absent_absent_defaultedOut {
+public:
+  Large_absent_absent_defaultedOut (void);
+  Large_absent_absent_defaultedOut (Large_absent_absent_defaultedOut &&rhs);
+
+
+  int data[150];
+};
+
+Large_absent_absent_defaultedOut::Large_absent_absent_defaultedOut (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_absent_absent_defaultedOut::Large_absent_absent_defaultedOut (Large_absent_absent_defaultedOut &&rhs) = default;
+
+
+Large_absent_absent_defaultedOut Large_absent_absent_defaultedOut_var; /* global var */
+
+template int cbv<Large_absent_absent_defaultedOut> (Large_absent_absent_defaultedOut arg);
+/*** Class derived from Small_absent_absent_defaultedOut ***/
+class Derived_absent_absent_defaultedOut : public Small_absent_absent_defaultedOut {
+public:
+};
+
+Derived_absent_absent_defaultedOut Derived_absent_absent_defaultedOut_var; /* global var */
+
+template int cbv<Derived_absent_absent_defaultedOut> (Derived_absent_absent_defaultedOut arg);
+/*** Class that contains Small_absent_absent_defaultedOut ***/
+class Container_absent_absent_defaultedOut {
+public:
+  Small_absent_absent_defaultedOut item;
+};
+
+Container_absent_absent_defaultedOut Container_absent_absent_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_absent_absent_defaultedOut> (Container_absent_absent_defaultedOut arg);
+/*** C++ class Small_absent_absent_deleted ***/
+class Small_absent_absent_deleted {
+public:
+  Small_absent_absent_deleted (void);
+  Small_absent_absent_deleted (Small_absent_absent_deleted &&rhs) = delete;
+
+
+  int data[2];
+};
+
+Small_absent_absent_deleted::Small_absent_absent_deleted (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+
+
+Small_absent_absent_deleted Small_absent_absent_deleted_var; /* global var */
+
+template int cbv<Small_absent_absent_deleted> (Small_absent_absent_deleted arg);
+/*** C++ class Large_absent_absent_deleted ***/
+class Large_absent_absent_deleted {
+public:
+  Large_absent_absent_deleted (void);
+  Large_absent_absent_deleted (Large_absent_absent_deleted &&rhs) = delete;
+
+
+  int data[150];
+};
+
+Large_absent_absent_deleted::Large_absent_absent_deleted (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+
+
+Large_absent_absent_deleted Large_absent_absent_deleted_var; /* global var */
+
+template int cbv<Large_absent_absent_deleted> (Large_absent_absent_deleted arg);
+/*** Class derived from Small_absent_absent_deleted ***/
+class Derived_absent_absent_deleted : public Small_absent_absent_deleted {
+public:
+};
+
+Derived_absent_absent_deleted Derived_absent_absent_deleted_var; /* global var */
+
+template int cbv<Derived_absent_absent_deleted> (Derived_absent_absent_deleted arg);
+/*** Class that contains Small_absent_absent_deleted ***/
+class Container_absent_absent_deleted {
+public:
+  Small_absent_absent_deleted item;
+};
+
+Container_absent_absent_deleted Container_absent_absent_deleted_var; /* global var */
+
+template int cbv_container<Container_absent_absent_deleted> (Container_absent_absent_deleted arg);
+/*** C++ class Small_absent_explicit_absent ***/
+class Small_absent_explicit_absent {
+public:
+  Small_absent_explicit_absent (void);
+  ~Small_absent_explicit_absent (void);
+
+
+  int data[2];
+};
+
+Small_absent_explicit_absent::Small_absent_explicit_absent (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_absent_explicit_absent::~Small_absent_explicit_absent (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_absent_explicit_absent Small_absent_explicit_absent_var; /* global var */
+
+template int cbv<Small_absent_explicit_absent> (Small_absent_explicit_absent arg);
+/*** C++ class Large_absent_explicit_absent ***/
+class Large_absent_explicit_absent {
+public:
+  Large_absent_explicit_absent (void);
+  ~Large_absent_explicit_absent (void);
+
+
+  int data[150];
+};
+
+Large_absent_explicit_absent::Large_absent_explicit_absent (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_absent_explicit_absent::~Large_absent_explicit_absent (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_absent_explicit_absent Large_absent_explicit_absent_var; /* global var */
+
+template int cbv<Large_absent_explicit_absent> (Large_absent_explicit_absent arg);
+/*** Class derived from Small_absent_explicit_absent ***/
+class Derived_absent_explicit_absent : public Small_absent_explicit_absent {
+public:
+};
+
+Derived_absent_explicit_absent Derived_absent_explicit_absent_var; /* global var */
+
+template int cbv<Derived_absent_explicit_absent> (Derived_absent_explicit_absent arg);
+/*** Class that contains Small_absent_explicit_absent ***/
+class Container_absent_explicit_absent {
+public:
+  Small_absent_explicit_absent item;
+};
+
+Container_absent_explicit_absent Container_absent_explicit_absent_var; /* global var */
+
+template int cbv_container<Container_absent_explicit_absent> (Container_absent_explicit_absent arg);
+/*** C++ class Small_absent_explicit_explicit ***/
+class Small_absent_explicit_explicit {
+public:
+  Small_absent_explicit_explicit (void);
+  ~Small_absent_explicit_explicit (void);
+  Small_absent_explicit_explicit (Small_absent_explicit_explicit &&rhs);
+
+
+  int data[2];
+};
+
+Small_absent_explicit_explicit::Small_absent_explicit_explicit (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_absent_explicit_explicit::~Small_absent_explicit_explicit (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_absent_explicit_explicit::Small_absent_explicit_explicit (Small_absent_explicit_explicit &&rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_absent_explicit_explicit Small_absent_explicit_explicit_var; /* global var */
+
+template int cbv<Small_absent_explicit_explicit> (Small_absent_explicit_explicit arg);
+/*** C++ class Large_absent_explicit_explicit ***/
+class Large_absent_explicit_explicit {
+public:
+  Large_absent_explicit_explicit (void);
+  ~Large_absent_explicit_explicit (void);
+  Large_absent_explicit_explicit (Large_absent_explicit_explicit &&rhs);
+
+
+  int data[150];
+};
+
+Large_absent_explicit_explicit::Large_absent_explicit_explicit (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_absent_explicit_explicit::~Large_absent_explicit_explicit (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_absent_explicit_explicit::Large_absent_explicit_explicit (Large_absent_explicit_explicit &&rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_absent_explicit_explicit Large_absent_explicit_explicit_var; /* global var */
+
+template int cbv<Large_absent_explicit_explicit> (Large_absent_explicit_explicit arg);
+/*** Class derived from Small_absent_explicit_explicit ***/
+class Derived_absent_explicit_explicit : public Small_absent_explicit_explicit {
+public:
+};
+
+Derived_absent_explicit_explicit Derived_absent_explicit_explicit_var; /* global var */
+
+template int cbv<Derived_absent_explicit_explicit> (Derived_absent_explicit_explicit arg);
+/*** Class that contains Small_absent_explicit_explicit ***/
+class Container_absent_explicit_explicit {
+public:
+  Small_absent_explicit_explicit item;
+};
+
+Container_absent_explicit_explicit Container_absent_explicit_explicit_var; /* global var */
+
+template int cbv_container<Container_absent_explicit_explicit> (Container_absent_explicit_explicit arg);
+/*** C++ class Small_absent_explicit_defaultedIn ***/
+class Small_absent_explicit_defaultedIn {
+public:
+  Small_absent_explicit_defaultedIn (void);
+  ~Small_absent_explicit_defaultedIn (void);
+  Small_absent_explicit_defaultedIn (Small_absent_explicit_defaultedIn &&rhs) = default;
+
+
+  int data[2];
+};
+
+Small_absent_explicit_defaultedIn::Small_absent_explicit_defaultedIn (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_absent_explicit_defaultedIn::~Small_absent_explicit_defaultedIn (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_absent_explicit_defaultedIn Small_absent_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Small_absent_explicit_defaultedIn> (Small_absent_explicit_defaultedIn arg);
+/*** C++ class Large_absent_explicit_defaultedIn ***/
+class Large_absent_explicit_defaultedIn {
+public:
+  Large_absent_explicit_defaultedIn (void);
+  ~Large_absent_explicit_defaultedIn (void);
+  Large_absent_explicit_defaultedIn (Large_absent_explicit_defaultedIn &&rhs) = default;
+
+
+  int data[150];
+};
+
+Large_absent_explicit_defaultedIn::Large_absent_explicit_defaultedIn (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_absent_explicit_defaultedIn::~Large_absent_explicit_defaultedIn (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_absent_explicit_defaultedIn Large_absent_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Large_absent_explicit_defaultedIn> (Large_absent_explicit_defaultedIn arg);
+/*** Class derived from Small_absent_explicit_defaultedIn ***/
+class Derived_absent_explicit_defaultedIn : public Small_absent_explicit_defaultedIn {
+public:
+};
+
+Derived_absent_explicit_defaultedIn Derived_absent_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Derived_absent_explicit_defaultedIn> (Derived_absent_explicit_defaultedIn arg);
+/*** Class that contains Small_absent_explicit_defaultedIn ***/
+class Container_absent_explicit_defaultedIn {
+public:
+  Small_absent_explicit_defaultedIn item;
+};
+
+Container_absent_explicit_defaultedIn Container_absent_explicit_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_absent_explicit_defaultedIn> (Container_absent_explicit_defaultedIn arg);
+/*** C++ class Small_absent_explicit_defaultedOut ***/
+class Small_absent_explicit_defaultedOut {
+public:
+  Small_absent_explicit_defaultedOut (void);
+  ~Small_absent_explicit_defaultedOut (void);
+  Small_absent_explicit_defaultedOut (Small_absent_explicit_defaultedOut &&rhs);
+
+
+  int data[2];
+};
+
+Small_absent_explicit_defaultedOut::Small_absent_explicit_defaultedOut (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_absent_explicit_defaultedOut::~Small_absent_explicit_defaultedOut (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_absent_explicit_defaultedOut::Small_absent_explicit_defaultedOut (Small_absent_explicit_defaultedOut &&rhs) = default;
+
+
+Small_absent_explicit_defaultedOut Small_absent_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Small_absent_explicit_defaultedOut> (Small_absent_explicit_defaultedOut arg);
+/*** C++ class Large_absent_explicit_defaultedOut ***/
+class Large_absent_explicit_defaultedOut {
+public:
+  Large_absent_explicit_defaultedOut (void);
+  ~Large_absent_explicit_defaultedOut (void);
+  Large_absent_explicit_defaultedOut (Large_absent_explicit_defaultedOut &&rhs);
+
+
+  int data[150];
+};
+
+Large_absent_explicit_defaultedOut::Large_absent_explicit_defaultedOut (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_absent_explicit_defaultedOut::~Large_absent_explicit_defaultedOut (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_absent_explicit_defaultedOut::Large_absent_explicit_defaultedOut (Large_absent_explicit_defaultedOut &&rhs) = default;
+
+
+Large_absent_explicit_defaultedOut Large_absent_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Large_absent_explicit_defaultedOut> (Large_absent_explicit_defaultedOut arg);
+/*** Class derived from Small_absent_explicit_defaultedOut ***/
+class Derived_absent_explicit_defaultedOut : public Small_absent_explicit_defaultedOut {
+public:
+};
+
+Derived_absent_explicit_defaultedOut Derived_absent_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Derived_absent_explicit_defaultedOut> (Derived_absent_explicit_defaultedOut arg);
+/*** Class that contains Small_absent_explicit_defaultedOut ***/
+class Container_absent_explicit_defaultedOut {
+public:
+  Small_absent_explicit_defaultedOut item;
+};
+
+Container_absent_explicit_defaultedOut Container_absent_explicit_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_absent_explicit_defaultedOut> (Container_absent_explicit_defaultedOut arg);
+/*** C++ class Small_absent_explicit_deleted ***/
+class Small_absent_explicit_deleted {
+public:
+  Small_absent_explicit_deleted (void);
+  ~Small_absent_explicit_deleted (void);
+  Small_absent_explicit_deleted (Small_absent_explicit_deleted &&rhs) = delete;
+
+
+  int data[2];
+};
+
+Small_absent_explicit_deleted::Small_absent_explicit_deleted (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_absent_explicit_deleted::~Small_absent_explicit_deleted (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_absent_explicit_deleted Small_absent_explicit_deleted_var; /* global var */
+
+template int cbv<Small_absent_explicit_deleted> (Small_absent_explicit_deleted arg);
+/*** C++ class Large_absent_explicit_deleted ***/
+class Large_absent_explicit_deleted {
+public:
+  Large_absent_explicit_deleted (void);
+  ~Large_absent_explicit_deleted (void);
+  Large_absent_explicit_deleted (Large_absent_explicit_deleted &&rhs) = delete;
+
+
+  int data[150];
+};
+
+Large_absent_explicit_deleted::Large_absent_explicit_deleted (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_absent_explicit_deleted::~Large_absent_explicit_deleted (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_absent_explicit_deleted Large_absent_explicit_deleted_var; /* global var */
+
+template int cbv<Large_absent_explicit_deleted> (Large_absent_explicit_deleted arg);
+/*** Class derived from Small_absent_explicit_deleted ***/
+class Derived_absent_explicit_deleted : public Small_absent_explicit_deleted {
+public:
+};
+
+Derived_absent_explicit_deleted Derived_absent_explicit_deleted_var; /* global var */
+
+template int cbv<Derived_absent_explicit_deleted> (Derived_absent_explicit_deleted arg);
+/*** Class that contains Small_absent_explicit_deleted ***/
+class Container_absent_explicit_deleted {
+public:
+  Small_absent_explicit_deleted item;
+};
+
+Container_absent_explicit_deleted Container_absent_explicit_deleted_var; /* global var */
+
+template int cbv_container<Container_absent_explicit_deleted> (Container_absent_explicit_deleted arg);
+/*** C++ class Small_absent_defaultedIn_absent ***/
+class Small_absent_defaultedIn_absent {
+public:
+  Small_absent_defaultedIn_absent (void);
+  ~Small_absent_defaultedIn_absent (void) = default;
+
+
+  int data[2];
+};
+
+Small_absent_defaultedIn_absent::Small_absent_defaultedIn_absent (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+
+
+Small_absent_defaultedIn_absent Small_absent_defaultedIn_absent_var; /* global var */
+
+template int cbv<Small_absent_defaultedIn_absent> (Small_absent_defaultedIn_absent arg);
+/*** C++ class Large_absent_defaultedIn_absent ***/
+class Large_absent_defaultedIn_absent {
+public:
+  Large_absent_defaultedIn_absent (void);
+  ~Large_absent_defaultedIn_absent (void) = default;
+
+
+  int data[150];
+};
+
+Large_absent_defaultedIn_absent::Large_absent_defaultedIn_absent (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+
+
+Large_absent_defaultedIn_absent Large_absent_defaultedIn_absent_var; /* global var */
+
+template int cbv<Large_absent_defaultedIn_absent> (Large_absent_defaultedIn_absent arg);
+/*** Class derived from Small_absent_defaultedIn_absent ***/
+class Derived_absent_defaultedIn_absent : public Small_absent_defaultedIn_absent {
+public:
+};
+
+Derived_absent_defaultedIn_absent Derived_absent_defaultedIn_absent_var; /* global var */
+
+template int cbv<Derived_absent_defaultedIn_absent> (Derived_absent_defaultedIn_absent arg);
+/*** Class that contains Small_absent_defaultedIn_absent ***/
+class Container_absent_defaultedIn_absent {
+public:
+  Small_absent_defaultedIn_absent item;
+};
+
+Container_absent_defaultedIn_absent Container_absent_defaultedIn_absent_var; /* global var */
+
+template int cbv_container<Container_absent_defaultedIn_absent> (Container_absent_defaultedIn_absent arg);
+/*** C++ class Small_absent_defaultedIn_explicit ***/
+class Small_absent_defaultedIn_explicit {
+public:
+  Small_absent_defaultedIn_explicit (void);
+  ~Small_absent_defaultedIn_explicit (void) = default;
+  Small_absent_defaultedIn_explicit (Small_absent_defaultedIn_explicit &&rhs);
+
+
+  int data[2];
+};
+
+Small_absent_defaultedIn_explicit::Small_absent_defaultedIn_explicit (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_absent_defaultedIn_explicit::Small_absent_defaultedIn_explicit (Small_absent_defaultedIn_explicit &&rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_absent_defaultedIn_explicit Small_absent_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Small_absent_defaultedIn_explicit> (Small_absent_defaultedIn_explicit arg);
+/*** C++ class Large_absent_defaultedIn_explicit ***/
+class Large_absent_defaultedIn_explicit {
+public:
+  Large_absent_defaultedIn_explicit (void);
+  ~Large_absent_defaultedIn_explicit (void) = default;
+  Large_absent_defaultedIn_explicit (Large_absent_defaultedIn_explicit &&rhs);
+
+
+  int data[150];
+};
+
+Large_absent_defaultedIn_explicit::Large_absent_defaultedIn_explicit (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_absent_defaultedIn_explicit::Large_absent_defaultedIn_explicit (Large_absent_defaultedIn_explicit &&rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_absent_defaultedIn_explicit Large_absent_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Large_absent_defaultedIn_explicit> (Large_absent_defaultedIn_explicit arg);
+/*** Class derived from Small_absent_defaultedIn_explicit ***/
+class Derived_absent_defaultedIn_explicit : public Small_absent_defaultedIn_explicit {
+public:
+};
+
+Derived_absent_defaultedIn_explicit Derived_absent_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Derived_absent_defaultedIn_explicit> (Derived_absent_defaultedIn_explicit arg);
+/*** Class that contains Small_absent_defaultedIn_explicit ***/
+class Container_absent_defaultedIn_explicit {
+public:
+  Small_absent_defaultedIn_explicit item;
+};
+
+Container_absent_defaultedIn_explicit Container_absent_defaultedIn_explicit_var; /* global var */
+
+template int cbv_container<Container_absent_defaultedIn_explicit> (Container_absent_defaultedIn_explicit arg);
+/*** C++ class Small_absent_defaultedIn_defaultedIn ***/
+class Small_absent_defaultedIn_defaultedIn {
+public:
+  Small_absent_defaultedIn_defaultedIn (void);
+  ~Small_absent_defaultedIn_defaultedIn (void) = default;
+  Small_absent_defaultedIn_defaultedIn (Small_absent_defaultedIn_defaultedIn &&rhs) = default;
+
+
+  int data[2];
+};
+
+Small_absent_defaultedIn_defaultedIn::Small_absent_defaultedIn_defaultedIn (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+
+
+Small_absent_defaultedIn_defaultedIn Small_absent_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Small_absent_defaultedIn_defaultedIn> (Small_absent_defaultedIn_defaultedIn arg);
+/*** C++ class Large_absent_defaultedIn_defaultedIn ***/
+class Large_absent_defaultedIn_defaultedIn {
+public:
+  Large_absent_defaultedIn_defaultedIn (void);
+  ~Large_absent_defaultedIn_defaultedIn (void) = default;
+  Large_absent_defaultedIn_defaultedIn (Large_absent_defaultedIn_defaultedIn &&rhs) = default;
+
+
+  int data[150];
+};
+
+Large_absent_defaultedIn_defaultedIn::Large_absent_defaultedIn_defaultedIn (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+
+
+Large_absent_defaultedIn_defaultedIn Large_absent_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Large_absent_defaultedIn_defaultedIn> (Large_absent_defaultedIn_defaultedIn arg);
+/*** Class derived from Small_absent_defaultedIn_defaultedIn ***/
+class Derived_absent_defaultedIn_defaultedIn : public Small_absent_defaultedIn_defaultedIn {
+public:
+};
+
+Derived_absent_defaultedIn_defaultedIn Derived_absent_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Derived_absent_defaultedIn_defaultedIn> (Derived_absent_defaultedIn_defaultedIn arg);
+/*** Class that contains Small_absent_defaultedIn_defaultedIn ***/
+class Container_absent_defaultedIn_defaultedIn {
+public:
+  Small_absent_defaultedIn_defaultedIn item;
+};
+
+Container_absent_defaultedIn_defaultedIn Container_absent_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_absent_defaultedIn_defaultedIn> (Container_absent_defaultedIn_defaultedIn arg);
+/*** C++ class Small_absent_defaultedIn_defaultedOut ***/
+class Small_absent_defaultedIn_defaultedOut {
+public:
+  Small_absent_defaultedIn_defaultedOut (void);
+  ~Small_absent_defaultedIn_defaultedOut (void) = default;
+  Small_absent_defaultedIn_defaultedOut (Small_absent_defaultedIn_defaultedOut &&rhs);
+
+
+  int data[2];
+};
+
+Small_absent_defaultedIn_defaultedOut::Small_absent_defaultedIn_defaultedOut (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_absent_defaultedIn_defaultedOut::Small_absent_defaultedIn_defaultedOut (Small_absent_defaultedIn_defaultedOut &&rhs) = default;
+
+
+Small_absent_defaultedIn_defaultedOut Small_absent_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Small_absent_defaultedIn_defaultedOut> (Small_absent_defaultedIn_defaultedOut arg);
+/*** C++ class Large_absent_defaultedIn_defaultedOut ***/
+class Large_absent_defaultedIn_defaultedOut {
+public:
+  Large_absent_defaultedIn_defaultedOut (void);
+  ~Large_absent_defaultedIn_defaultedOut (void) = default;
+  Large_absent_defaultedIn_defaultedOut (Large_absent_defaultedIn_defaultedOut &&rhs);
+
+
+  int data[150];
+};
+
+Large_absent_defaultedIn_defaultedOut::Large_absent_defaultedIn_defaultedOut (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_absent_defaultedIn_defaultedOut::Large_absent_defaultedIn_defaultedOut (Large_absent_defaultedIn_defaultedOut &&rhs) = default;
+
+
+Large_absent_defaultedIn_defaultedOut Large_absent_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Large_absent_defaultedIn_defaultedOut> (Large_absent_defaultedIn_defaultedOut arg);
+/*** Class derived from Small_absent_defaultedIn_defaultedOut ***/
+class Derived_absent_defaultedIn_defaultedOut : public Small_absent_defaultedIn_defaultedOut {
+public:
+};
+
+Derived_absent_defaultedIn_defaultedOut Derived_absent_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Derived_absent_defaultedIn_defaultedOut> (Derived_absent_defaultedIn_defaultedOut arg);
+/*** Class that contains Small_absent_defaultedIn_defaultedOut ***/
+class Container_absent_defaultedIn_defaultedOut {
+public:
+  Small_absent_defaultedIn_defaultedOut item;
+};
+
+Container_absent_defaultedIn_defaultedOut Container_absent_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_absent_defaultedIn_defaultedOut> (Container_absent_defaultedIn_defaultedOut arg);
+/*** C++ class Small_absent_defaultedIn_deleted ***/
+class Small_absent_defaultedIn_deleted {
+public:
+  Small_absent_defaultedIn_deleted (void);
+  ~Small_absent_defaultedIn_deleted (void) = default;
+  Small_absent_defaultedIn_deleted (Small_absent_defaultedIn_deleted &&rhs) = delete;
+
+
+  int data[2];
+};
+
+Small_absent_defaultedIn_deleted::Small_absent_defaultedIn_deleted (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+
+
+Small_absent_defaultedIn_deleted Small_absent_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Small_absent_defaultedIn_deleted> (Small_absent_defaultedIn_deleted arg);
+/*** C++ class Large_absent_defaultedIn_deleted ***/
+class Large_absent_defaultedIn_deleted {
+public:
+  Large_absent_defaultedIn_deleted (void);
+  ~Large_absent_defaultedIn_deleted (void) = default;
+  Large_absent_defaultedIn_deleted (Large_absent_defaultedIn_deleted &&rhs) = delete;
+
+
+  int data[150];
+};
+
+Large_absent_defaultedIn_deleted::Large_absent_defaultedIn_deleted (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+
+
+Large_absent_defaultedIn_deleted Large_absent_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Large_absent_defaultedIn_deleted> (Large_absent_defaultedIn_deleted arg);
+/*** Class derived from Small_absent_defaultedIn_deleted ***/
+class Derived_absent_defaultedIn_deleted : public Small_absent_defaultedIn_deleted {
+public:
+};
+
+Derived_absent_defaultedIn_deleted Derived_absent_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Derived_absent_defaultedIn_deleted> (Derived_absent_defaultedIn_deleted arg);
+/*** Class that contains Small_absent_defaultedIn_deleted ***/
+class Container_absent_defaultedIn_deleted {
+public:
+  Small_absent_defaultedIn_deleted item;
+};
+
+Container_absent_defaultedIn_deleted Container_absent_defaultedIn_deleted_var; /* global var */
+
+template int cbv_container<Container_absent_defaultedIn_deleted> (Container_absent_defaultedIn_deleted arg);
+/*** C++ class Small_absent_defaultedOut_absent ***/
+class Small_absent_defaultedOut_absent {
+public:
+  Small_absent_defaultedOut_absent (void);
+  ~Small_absent_defaultedOut_absent (void);
+
+
+  int data[2];
+};
+
+Small_absent_defaultedOut_absent::Small_absent_defaultedOut_absent (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_absent_defaultedOut_absent::~Small_absent_defaultedOut_absent (void) = default;
+
+
+Small_absent_defaultedOut_absent Small_absent_defaultedOut_absent_var; /* global var */
+
+template int cbv<Small_absent_defaultedOut_absent> (Small_absent_defaultedOut_absent arg);
+/*** C++ class Large_absent_defaultedOut_absent ***/
+class Large_absent_defaultedOut_absent {
+public:
+  Large_absent_defaultedOut_absent (void);
+  ~Large_absent_defaultedOut_absent (void);
+
+
+  int data[150];
+};
+
+Large_absent_defaultedOut_absent::Large_absent_defaultedOut_absent (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_absent_defaultedOut_absent::~Large_absent_defaultedOut_absent (void) = default;
+
+
+Large_absent_defaultedOut_absent Large_absent_defaultedOut_absent_var; /* global var */
+
+template int cbv<Large_absent_defaultedOut_absent> (Large_absent_defaultedOut_absent arg);
+/*** Class derived from Small_absent_defaultedOut_absent ***/
+class Derived_absent_defaultedOut_absent : public Small_absent_defaultedOut_absent {
+public:
+};
+
+Derived_absent_defaultedOut_absent Derived_absent_defaultedOut_absent_var; /* global var */
+
+template int cbv<Derived_absent_defaultedOut_absent> (Derived_absent_defaultedOut_absent arg);
+/*** Class that contains Small_absent_defaultedOut_absent ***/
+class Container_absent_defaultedOut_absent {
+public:
+  Small_absent_defaultedOut_absent item;
+};
+
+Container_absent_defaultedOut_absent Container_absent_defaultedOut_absent_var; /* global var */
+
+template int cbv_container<Container_absent_defaultedOut_absent> (Container_absent_defaultedOut_absent arg);
+/*** C++ class Small_absent_defaultedOut_explicit ***/
+class Small_absent_defaultedOut_explicit {
+public:
+  Small_absent_defaultedOut_explicit (void);
+  ~Small_absent_defaultedOut_explicit (void);
+  Small_absent_defaultedOut_explicit (Small_absent_defaultedOut_explicit &&rhs);
+
+
+  int data[2];
+};
+
+Small_absent_defaultedOut_explicit::Small_absent_defaultedOut_explicit (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_absent_defaultedOut_explicit::~Small_absent_defaultedOut_explicit (void) = default;
+Small_absent_defaultedOut_explicit::Small_absent_defaultedOut_explicit (Small_absent_defaultedOut_explicit &&rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_absent_defaultedOut_explicit Small_absent_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Small_absent_defaultedOut_explicit> (Small_absent_defaultedOut_explicit arg);
+/*** C++ class Large_absent_defaultedOut_explicit ***/
+class Large_absent_defaultedOut_explicit {
+public:
+  Large_absent_defaultedOut_explicit (void);
+  ~Large_absent_defaultedOut_explicit (void);
+  Large_absent_defaultedOut_explicit (Large_absent_defaultedOut_explicit &&rhs);
+
+
+  int data[150];
+};
+
+Large_absent_defaultedOut_explicit::Large_absent_defaultedOut_explicit (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_absent_defaultedOut_explicit::~Large_absent_defaultedOut_explicit (void) = default;
+Large_absent_defaultedOut_explicit::Large_absent_defaultedOut_explicit (Large_absent_defaultedOut_explicit &&rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_absent_defaultedOut_explicit Large_absent_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Large_absent_defaultedOut_explicit> (Large_absent_defaultedOut_explicit arg);
+/*** Class derived from Small_absent_defaultedOut_explicit ***/
+class Derived_absent_defaultedOut_explicit : public Small_absent_defaultedOut_explicit {
+public:
+};
+
+Derived_absent_defaultedOut_explicit Derived_absent_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Derived_absent_defaultedOut_explicit> (Derived_absent_defaultedOut_explicit arg);
+/*** Class that contains Small_absent_defaultedOut_explicit ***/
+class Container_absent_defaultedOut_explicit {
+public:
+  Small_absent_defaultedOut_explicit item;
+};
+
+Container_absent_defaultedOut_explicit Container_absent_defaultedOut_explicit_var; /* global var */
+
+template int cbv_container<Container_absent_defaultedOut_explicit> (Container_absent_defaultedOut_explicit arg);
+/*** C++ class Small_absent_defaultedOut_defaultedIn ***/
+class Small_absent_defaultedOut_defaultedIn {
+public:
+  Small_absent_defaultedOut_defaultedIn (void);
+  ~Small_absent_defaultedOut_defaultedIn (void);
+  Small_absent_defaultedOut_defaultedIn (Small_absent_defaultedOut_defaultedIn &&rhs) = default;
+
+
+  int data[2];
+};
+
+Small_absent_defaultedOut_defaultedIn::Small_absent_defaultedOut_defaultedIn (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_absent_defaultedOut_defaultedIn::~Small_absent_defaultedOut_defaultedIn (void) = default;
+
+
+Small_absent_defaultedOut_defaultedIn Small_absent_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Small_absent_defaultedOut_defaultedIn> (Small_absent_defaultedOut_defaultedIn arg);
+/*** C++ class Large_absent_defaultedOut_defaultedIn ***/
+class Large_absent_defaultedOut_defaultedIn {
+public:
+  Large_absent_defaultedOut_defaultedIn (void);
+  ~Large_absent_defaultedOut_defaultedIn (void);
+  Large_absent_defaultedOut_defaultedIn (Large_absent_defaultedOut_defaultedIn &&rhs) = default;
+
+
+  int data[150];
+};
+
+Large_absent_defaultedOut_defaultedIn::Large_absent_defaultedOut_defaultedIn (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_absent_defaultedOut_defaultedIn::~Large_absent_defaultedOut_defaultedIn (void) = default;
+
+
+Large_absent_defaultedOut_defaultedIn Large_absent_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Large_absent_defaultedOut_defaultedIn> (Large_absent_defaultedOut_defaultedIn arg);
+/*** Class derived from Small_absent_defaultedOut_defaultedIn ***/
+class Derived_absent_defaultedOut_defaultedIn : public Small_absent_defaultedOut_defaultedIn {
+public:
+};
+
+Derived_absent_defaultedOut_defaultedIn Derived_absent_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Derived_absent_defaultedOut_defaultedIn> (Derived_absent_defaultedOut_defaultedIn arg);
+/*** Class that contains Small_absent_defaultedOut_defaultedIn ***/
+class Container_absent_defaultedOut_defaultedIn {
+public:
+  Small_absent_defaultedOut_defaultedIn item;
+};
+
+Container_absent_defaultedOut_defaultedIn Container_absent_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_absent_defaultedOut_defaultedIn> (Container_absent_defaultedOut_defaultedIn arg);
+/*** C++ class Small_absent_defaultedOut_defaultedOut ***/
+class Small_absent_defaultedOut_defaultedOut {
+public:
+  Small_absent_defaultedOut_defaultedOut (void);
+  ~Small_absent_defaultedOut_defaultedOut (void);
+  Small_absent_defaultedOut_defaultedOut (Small_absent_defaultedOut_defaultedOut &&rhs);
+
+
+  int data[2];
+};
+
+Small_absent_defaultedOut_defaultedOut::Small_absent_defaultedOut_defaultedOut (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_absent_defaultedOut_defaultedOut::~Small_absent_defaultedOut_defaultedOut (void) = default;
+Small_absent_defaultedOut_defaultedOut::Small_absent_defaultedOut_defaultedOut (Small_absent_defaultedOut_defaultedOut &&rhs) = default;
+
+
+Small_absent_defaultedOut_defaultedOut Small_absent_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Small_absent_defaultedOut_defaultedOut> (Small_absent_defaultedOut_defaultedOut arg);
+/*** C++ class Large_absent_defaultedOut_defaultedOut ***/
+class Large_absent_defaultedOut_defaultedOut {
+public:
+  Large_absent_defaultedOut_defaultedOut (void);
+  ~Large_absent_defaultedOut_defaultedOut (void);
+  Large_absent_defaultedOut_defaultedOut (Large_absent_defaultedOut_defaultedOut &&rhs);
+
+
+  int data[150];
+};
+
+Large_absent_defaultedOut_defaultedOut::Large_absent_defaultedOut_defaultedOut (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_absent_defaultedOut_defaultedOut::~Large_absent_defaultedOut_defaultedOut (void) = default;
+Large_absent_defaultedOut_defaultedOut::Large_absent_defaultedOut_defaultedOut (Large_absent_defaultedOut_defaultedOut &&rhs) = default;
+
+
+Large_absent_defaultedOut_defaultedOut Large_absent_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Large_absent_defaultedOut_defaultedOut> (Large_absent_defaultedOut_defaultedOut arg);
+/*** Class derived from Small_absent_defaultedOut_defaultedOut ***/
+class Derived_absent_defaultedOut_defaultedOut : public Small_absent_defaultedOut_defaultedOut {
+public:
+};
+
+Derived_absent_defaultedOut_defaultedOut Derived_absent_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Derived_absent_defaultedOut_defaultedOut> (Derived_absent_defaultedOut_defaultedOut arg);
+/*** Class that contains Small_absent_defaultedOut_defaultedOut ***/
+class Container_absent_defaultedOut_defaultedOut {
+public:
+  Small_absent_defaultedOut_defaultedOut item;
+};
+
+Container_absent_defaultedOut_defaultedOut Container_absent_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_absent_defaultedOut_defaultedOut> (Container_absent_defaultedOut_defaultedOut arg);
+/*** C++ class Small_absent_defaultedOut_deleted ***/
+class Small_absent_defaultedOut_deleted {
+public:
+  Small_absent_defaultedOut_deleted (void);
+  ~Small_absent_defaultedOut_deleted (void);
+  Small_absent_defaultedOut_deleted (Small_absent_defaultedOut_deleted &&rhs) = delete;
+
+
+  int data[2];
+};
+
+Small_absent_defaultedOut_deleted::Small_absent_defaultedOut_deleted (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_absent_defaultedOut_deleted::~Small_absent_defaultedOut_deleted (void) = default;
+
+
+Small_absent_defaultedOut_deleted Small_absent_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Small_absent_defaultedOut_deleted> (Small_absent_defaultedOut_deleted arg);
+/*** C++ class Large_absent_defaultedOut_deleted ***/
+class Large_absent_defaultedOut_deleted {
+public:
+  Large_absent_defaultedOut_deleted (void);
+  ~Large_absent_defaultedOut_deleted (void);
+  Large_absent_defaultedOut_deleted (Large_absent_defaultedOut_deleted &&rhs) = delete;
+
+
+  int data[150];
+};
+
+Large_absent_defaultedOut_deleted::Large_absent_defaultedOut_deleted (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_absent_defaultedOut_deleted::~Large_absent_defaultedOut_deleted (void) = default;
+
+
+Large_absent_defaultedOut_deleted Large_absent_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Large_absent_defaultedOut_deleted> (Large_absent_defaultedOut_deleted arg);
+/*** Class derived from Small_absent_defaultedOut_deleted ***/
+class Derived_absent_defaultedOut_deleted : public Small_absent_defaultedOut_deleted {
+public:
+};
+
+Derived_absent_defaultedOut_deleted Derived_absent_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Derived_absent_defaultedOut_deleted> (Derived_absent_defaultedOut_deleted arg);
+/*** Class that contains Small_absent_defaultedOut_deleted ***/
+class Container_absent_defaultedOut_deleted {
+public:
+  Small_absent_defaultedOut_deleted item;
+};
+
+Container_absent_defaultedOut_deleted Container_absent_defaultedOut_deleted_var; /* global var */
+
+template int cbv_container<Container_absent_defaultedOut_deleted> (Container_absent_defaultedOut_deleted arg);
+/*** C++ class Small_explicit_absent_absent ***/
+class Small_explicit_absent_absent {
+public:
+  Small_explicit_absent_absent (void);
+  Small_explicit_absent_absent (const Small_explicit_absent_absent &rhs);
+
+
+  int data[2];
+};
+
+Small_explicit_absent_absent::Small_explicit_absent_absent (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_explicit_absent_absent::Small_explicit_absent_absent (const Small_explicit_absent_absent &rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_explicit_absent_absent Small_explicit_absent_absent_var; /* global var */
+
+template int cbv<Small_explicit_absent_absent> (Small_explicit_absent_absent arg);
+/*** C++ class Large_explicit_absent_absent ***/
+class Large_explicit_absent_absent {
+public:
+  Large_explicit_absent_absent (void);
+  Large_explicit_absent_absent (const Large_explicit_absent_absent &rhs);
+
+
+  int data[150];
+};
+
+Large_explicit_absent_absent::Large_explicit_absent_absent (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_explicit_absent_absent::Large_explicit_absent_absent (const Large_explicit_absent_absent &rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_explicit_absent_absent Large_explicit_absent_absent_var; /* global var */
+
+template int cbv<Large_explicit_absent_absent> (Large_explicit_absent_absent arg);
+/*** Class derived from Small_explicit_absent_absent ***/
+class Derived_explicit_absent_absent : public Small_explicit_absent_absent {
+public:
+};
+
+Derived_explicit_absent_absent Derived_explicit_absent_absent_var; /* global var */
+
+template int cbv<Derived_explicit_absent_absent> (Derived_explicit_absent_absent arg);
+/*** Class that contains Small_explicit_absent_absent ***/
+class Container_explicit_absent_absent {
+public:
+  Small_explicit_absent_absent item;
+};
+
+Container_explicit_absent_absent Container_explicit_absent_absent_var; /* global var */
+
+template int cbv_container<Container_explicit_absent_absent> (Container_explicit_absent_absent arg);
+/*** C++ class Small_explicit_absent_explicit ***/
+class Small_explicit_absent_explicit {
+public:
+  Small_explicit_absent_explicit (void);
+  Small_explicit_absent_explicit (const Small_explicit_absent_explicit &rhs);
+  Small_explicit_absent_explicit (Small_explicit_absent_explicit &&rhs);
+
+
+  int data[2];
+};
+
+Small_explicit_absent_explicit::Small_explicit_absent_explicit (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_explicit_absent_explicit::Small_explicit_absent_explicit (const Small_explicit_absent_explicit &rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_explicit_absent_explicit::Small_explicit_absent_explicit (Small_explicit_absent_explicit &&rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_explicit_absent_explicit Small_explicit_absent_explicit_var; /* global var */
+
+template int cbv<Small_explicit_absent_explicit> (Small_explicit_absent_explicit arg);
+/*** C++ class Large_explicit_absent_explicit ***/
+class Large_explicit_absent_explicit {
+public:
+  Large_explicit_absent_explicit (void);
+  Large_explicit_absent_explicit (const Large_explicit_absent_explicit &rhs);
+  Large_explicit_absent_explicit (Large_explicit_absent_explicit &&rhs);
+
+
+  int data[150];
+};
+
+Large_explicit_absent_explicit::Large_explicit_absent_explicit (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_explicit_absent_explicit::Large_explicit_absent_explicit (const Large_explicit_absent_explicit &rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_explicit_absent_explicit::Large_explicit_absent_explicit (Large_explicit_absent_explicit &&rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_explicit_absent_explicit Large_explicit_absent_explicit_var; /* global var */
+
+template int cbv<Large_explicit_absent_explicit> (Large_explicit_absent_explicit arg);
+/*** Class derived from Small_explicit_absent_explicit ***/
+class Derived_explicit_absent_explicit : public Small_explicit_absent_explicit {
+public:
+};
+
+Derived_explicit_absent_explicit Derived_explicit_absent_explicit_var; /* global var */
+
+template int cbv<Derived_explicit_absent_explicit> (Derived_explicit_absent_explicit arg);
+/*** Class that contains Small_explicit_absent_explicit ***/
+class Container_explicit_absent_explicit {
+public:
+  Small_explicit_absent_explicit item;
+};
+
+Container_explicit_absent_explicit Container_explicit_absent_explicit_var; /* global var */
+
+template int cbv_container<Container_explicit_absent_explicit> (Container_explicit_absent_explicit arg);
+/*** C++ class Small_explicit_absent_defaultedIn ***/
+class Small_explicit_absent_defaultedIn {
+public:
+  Small_explicit_absent_defaultedIn (void);
+  Small_explicit_absent_defaultedIn (const Small_explicit_absent_defaultedIn &rhs);
+  Small_explicit_absent_defaultedIn (Small_explicit_absent_defaultedIn &&rhs) = default;
+
+
+  int data[2];
+};
+
+Small_explicit_absent_defaultedIn::Small_explicit_absent_defaultedIn (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_explicit_absent_defaultedIn::Small_explicit_absent_defaultedIn (const Small_explicit_absent_defaultedIn &rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_explicit_absent_defaultedIn Small_explicit_absent_defaultedIn_var; /* global var */
+
+template int cbv<Small_explicit_absent_defaultedIn> (Small_explicit_absent_defaultedIn arg);
+/*** C++ class Large_explicit_absent_defaultedIn ***/
+class Large_explicit_absent_defaultedIn {
+public:
+  Large_explicit_absent_defaultedIn (void);
+  Large_explicit_absent_defaultedIn (const Large_explicit_absent_defaultedIn &rhs);
+  Large_explicit_absent_defaultedIn (Large_explicit_absent_defaultedIn &&rhs) = default;
+
+
+  int data[150];
+};
+
+Large_explicit_absent_defaultedIn::Large_explicit_absent_defaultedIn (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_explicit_absent_defaultedIn::Large_explicit_absent_defaultedIn (const Large_explicit_absent_defaultedIn &rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_explicit_absent_defaultedIn Large_explicit_absent_defaultedIn_var; /* global var */
+
+template int cbv<Large_explicit_absent_defaultedIn> (Large_explicit_absent_defaultedIn arg);
+/*** Class derived from Small_explicit_absent_defaultedIn ***/
+class Derived_explicit_absent_defaultedIn : public Small_explicit_absent_defaultedIn {
+public:
+};
+
+Derived_explicit_absent_defaultedIn Derived_explicit_absent_defaultedIn_var; /* global var */
+
+template int cbv<Derived_explicit_absent_defaultedIn> (Derived_explicit_absent_defaultedIn arg);
+/*** Class that contains Small_explicit_absent_defaultedIn ***/
+class Container_explicit_absent_defaultedIn {
+public:
+  Small_explicit_absent_defaultedIn item;
+};
+
+Container_explicit_absent_defaultedIn Container_explicit_absent_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_explicit_absent_defaultedIn> (Container_explicit_absent_defaultedIn arg);
+/*** C++ class Small_explicit_absent_defaultedOut ***/
+class Small_explicit_absent_defaultedOut {
+public:
+  Small_explicit_absent_defaultedOut (void);
+  Small_explicit_absent_defaultedOut (const Small_explicit_absent_defaultedOut &rhs);
+  Small_explicit_absent_defaultedOut (Small_explicit_absent_defaultedOut &&rhs);
+
+
+  int data[2];
+};
+
+Small_explicit_absent_defaultedOut::Small_explicit_absent_defaultedOut (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_explicit_absent_defaultedOut::Small_explicit_absent_defaultedOut (const Small_explicit_absent_defaultedOut &rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_explicit_absent_defaultedOut::Small_explicit_absent_defaultedOut (Small_explicit_absent_defaultedOut &&rhs) = default;
+
+
+Small_explicit_absent_defaultedOut Small_explicit_absent_defaultedOut_var; /* global var */
+
+template int cbv<Small_explicit_absent_defaultedOut> (Small_explicit_absent_defaultedOut arg);
+/*** C++ class Large_explicit_absent_defaultedOut ***/
+class Large_explicit_absent_defaultedOut {
+public:
+  Large_explicit_absent_defaultedOut (void);
+  Large_explicit_absent_defaultedOut (const Large_explicit_absent_defaultedOut &rhs);
+  Large_explicit_absent_defaultedOut (Large_explicit_absent_defaultedOut &&rhs);
+
+
+  int data[150];
+};
+
+Large_explicit_absent_defaultedOut::Large_explicit_absent_defaultedOut (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_explicit_absent_defaultedOut::Large_explicit_absent_defaultedOut (const Large_explicit_absent_defaultedOut &rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_explicit_absent_defaultedOut::Large_explicit_absent_defaultedOut (Large_explicit_absent_defaultedOut &&rhs) = default;
+
+
+Large_explicit_absent_defaultedOut Large_explicit_absent_defaultedOut_var; /* global var */
+
+template int cbv<Large_explicit_absent_defaultedOut> (Large_explicit_absent_defaultedOut arg);
+/*** Class derived from Small_explicit_absent_defaultedOut ***/
+class Derived_explicit_absent_defaultedOut : public Small_explicit_absent_defaultedOut {
+public:
+};
+
+Derived_explicit_absent_defaultedOut Derived_explicit_absent_defaultedOut_var; /* global var */
+
+template int cbv<Derived_explicit_absent_defaultedOut> (Derived_explicit_absent_defaultedOut arg);
+/*** Class that contains Small_explicit_absent_defaultedOut ***/
+class Container_explicit_absent_defaultedOut {
+public:
+  Small_explicit_absent_defaultedOut item;
+};
+
+Container_explicit_absent_defaultedOut Container_explicit_absent_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_explicit_absent_defaultedOut> (Container_explicit_absent_defaultedOut arg);
+/*** C++ class Small_explicit_absent_deleted ***/
+class Small_explicit_absent_deleted {
+public:
+  Small_explicit_absent_deleted (void);
+  Small_explicit_absent_deleted (const Small_explicit_absent_deleted &rhs);
+  Small_explicit_absent_deleted (Small_explicit_absent_deleted &&rhs) = delete;
+
+
+  int data[2];
+};
+
+Small_explicit_absent_deleted::Small_explicit_absent_deleted (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_explicit_absent_deleted::Small_explicit_absent_deleted (const Small_explicit_absent_deleted &rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_explicit_absent_deleted Small_explicit_absent_deleted_var; /* global var */
+
+template int cbv<Small_explicit_absent_deleted> (Small_explicit_absent_deleted arg);
+/*** C++ class Large_explicit_absent_deleted ***/
+class Large_explicit_absent_deleted {
+public:
+  Large_explicit_absent_deleted (void);
+  Large_explicit_absent_deleted (const Large_explicit_absent_deleted &rhs);
+  Large_explicit_absent_deleted (Large_explicit_absent_deleted &&rhs) = delete;
+
+
+  int data[150];
+};
+
+Large_explicit_absent_deleted::Large_explicit_absent_deleted (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_explicit_absent_deleted::Large_explicit_absent_deleted (const Large_explicit_absent_deleted &rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_explicit_absent_deleted Large_explicit_absent_deleted_var; /* global var */
+
+template int cbv<Large_explicit_absent_deleted> (Large_explicit_absent_deleted arg);
+/*** Class derived from Small_explicit_absent_deleted ***/
+class Derived_explicit_absent_deleted : public Small_explicit_absent_deleted {
+public:
+};
+
+Derived_explicit_absent_deleted Derived_explicit_absent_deleted_var; /* global var */
+
+template int cbv<Derived_explicit_absent_deleted> (Derived_explicit_absent_deleted arg);
+/*** Class that contains Small_explicit_absent_deleted ***/
+class Container_explicit_absent_deleted {
+public:
+  Small_explicit_absent_deleted item;
+};
+
+Container_explicit_absent_deleted Container_explicit_absent_deleted_var; /* global var */
+
+template int cbv_container<Container_explicit_absent_deleted> (Container_explicit_absent_deleted arg);
+/*** C++ class Small_explicit_explicit_absent ***/
+class Small_explicit_explicit_absent {
+public:
+  Small_explicit_explicit_absent (void);
+  Small_explicit_explicit_absent (const Small_explicit_explicit_absent &rhs);
+  ~Small_explicit_explicit_absent (void);
+
+
+  int data[2];
+};
+
+Small_explicit_explicit_absent::Small_explicit_explicit_absent (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_explicit_explicit_absent::Small_explicit_explicit_absent (const Small_explicit_explicit_absent &rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_explicit_explicit_absent::~Small_explicit_explicit_absent (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_explicit_explicit_absent Small_explicit_explicit_absent_var; /* global var */
+
+template int cbv<Small_explicit_explicit_absent> (Small_explicit_explicit_absent arg);
+/*** C++ class Large_explicit_explicit_absent ***/
+class Large_explicit_explicit_absent {
+public:
+  Large_explicit_explicit_absent (void);
+  Large_explicit_explicit_absent (const Large_explicit_explicit_absent &rhs);
+  ~Large_explicit_explicit_absent (void);
+
+
+  int data[150];
+};
+
+Large_explicit_explicit_absent::Large_explicit_explicit_absent (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_explicit_explicit_absent::Large_explicit_explicit_absent (const Large_explicit_explicit_absent &rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_explicit_explicit_absent::~Large_explicit_explicit_absent (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_explicit_explicit_absent Large_explicit_explicit_absent_var; /* global var */
+
+template int cbv<Large_explicit_explicit_absent> (Large_explicit_explicit_absent arg);
+/*** Class derived from Small_explicit_explicit_absent ***/
+class Derived_explicit_explicit_absent : public Small_explicit_explicit_absent {
+public:
+};
+
+Derived_explicit_explicit_absent Derived_explicit_explicit_absent_var; /* global var */
+
+template int cbv<Derived_explicit_explicit_absent> (Derived_explicit_explicit_absent arg);
+/*** Class that contains Small_explicit_explicit_absent ***/
+class Container_explicit_explicit_absent {
+public:
+  Small_explicit_explicit_absent item;
+};
+
+Container_explicit_explicit_absent Container_explicit_explicit_absent_var; /* global var */
+
+template int cbv_container<Container_explicit_explicit_absent> (Container_explicit_explicit_absent arg);
+/*** C++ class Small_explicit_explicit_explicit ***/
+class Small_explicit_explicit_explicit {
+public:
+  Small_explicit_explicit_explicit (void);
+  Small_explicit_explicit_explicit (const Small_explicit_explicit_explicit &rhs);
+  ~Small_explicit_explicit_explicit (void);
+  Small_explicit_explicit_explicit (Small_explicit_explicit_explicit &&rhs);
+
+
+  int data[2];
+};
+
+Small_explicit_explicit_explicit::Small_explicit_explicit_explicit (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_explicit_explicit_explicit::Small_explicit_explicit_explicit (const Small_explicit_explicit_explicit &rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_explicit_explicit_explicit::~Small_explicit_explicit_explicit (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_explicit_explicit_explicit::Small_explicit_explicit_explicit (Small_explicit_explicit_explicit &&rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_explicit_explicit_explicit Small_explicit_explicit_explicit_var; /* global var */
+
+template int cbv<Small_explicit_explicit_explicit> (Small_explicit_explicit_explicit arg);
+/*** C++ class Large_explicit_explicit_explicit ***/
+class Large_explicit_explicit_explicit {
+public:
+  Large_explicit_explicit_explicit (void);
+  Large_explicit_explicit_explicit (const Large_explicit_explicit_explicit &rhs);
+  ~Large_explicit_explicit_explicit (void);
+  Large_explicit_explicit_explicit (Large_explicit_explicit_explicit &&rhs);
+
+
+  int data[150];
+};
+
+Large_explicit_explicit_explicit::Large_explicit_explicit_explicit (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_explicit_explicit_explicit::Large_explicit_explicit_explicit (const Large_explicit_explicit_explicit &rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_explicit_explicit_explicit::~Large_explicit_explicit_explicit (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_explicit_explicit_explicit::Large_explicit_explicit_explicit (Large_explicit_explicit_explicit &&rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_explicit_explicit_explicit Large_explicit_explicit_explicit_var; /* global var */
+
+template int cbv<Large_explicit_explicit_explicit> (Large_explicit_explicit_explicit arg);
+/*** Class derived from Small_explicit_explicit_explicit ***/
+class Derived_explicit_explicit_explicit : public Small_explicit_explicit_explicit {
+public:
+};
+
+Derived_explicit_explicit_explicit Derived_explicit_explicit_explicit_var; /* global var */
+
+template int cbv<Derived_explicit_explicit_explicit> (Derived_explicit_explicit_explicit arg);
+/*** Class that contains Small_explicit_explicit_explicit ***/
+class Container_explicit_explicit_explicit {
+public:
+  Small_explicit_explicit_explicit item;
+};
+
+Container_explicit_explicit_explicit Container_explicit_explicit_explicit_var; /* global var */
+
+template int cbv_container<Container_explicit_explicit_explicit> (Container_explicit_explicit_explicit arg);
+/*** C++ class Small_explicit_explicit_defaultedIn ***/
+class Small_explicit_explicit_defaultedIn {
+public:
+  Small_explicit_explicit_defaultedIn (void);
+  Small_explicit_explicit_defaultedIn (const Small_explicit_explicit_defaultedIn &rhs);
+  ~Small_explicit_explicit_defaultedIn (void);
+  Small_explicit_explicit_defaultedIn (Small_explicit_explicit_defaultedIn &&rhs) = default;
+
+
+  int data[2];
+};
+
+Small_explicit_explicit_defaultedIn::Small_explicit_explicit_defaultedIn (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_explicit_explicit_defaultedIn::Small_explicit_explicit_defaultedIn (const Small_explicit_explicit_defaultedIn &rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_explicit_explicit_defaultedIn::~Small_explicit_explicit_defaultedIn (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_explicit_explicit_defaultedIn Small_explicit_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Small_explicit_explicit_defaultedIn> (Small_explicit_explicit_defaultedIn arg);
+/*** C++ class Large_explicit_explicit_defaultedIn ***/
+class Large_explicit_explicit_defaultedIn {
+public:
+  Large_explicit_explicit_defaultedIn (void);
+  Large_explicit_explicit_defaultedIn (const Large_explicit_explicit_defaultedIn &rhs);
+  ~Large_explicit_explicit_defaultedIn (void);
+  Large_explicit_explicit_defaultedIn (Large_explicit_explicit_defaultedIn &&rhs) = default;
+
+
+  int data[150];
+};
+
+Large_explicit_explicit_defaultedIn::Large_explicit_explicit_defaultedIn (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_explicit_explicit_defaultedIn::Large_explicit_explicit_defaultedIn (const Large_explicit_explicit_defaultedIn &rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_explicit_explicit_defaultedIn::~Large_explicit_explicit_defaultedIn (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_explicit_explicit_defaultedIn Large_explicit_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Large_explicit_explicit_defaultedIn> (Large_explicit_explicit_defaultedIn arg);
+/*** Class derived from Small_explicit_explicit_defaultedIn ***/
+class Derived_explicit_explicit_defaultedIn : public Small_explicit_explicit_defaultedIn {
+public:
+};
+
+Derived_explicit_explicit_defaultedIn Derived_explicit_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Derived_explicit_explicit_defaultedIn> (Derived_explicit_explicit_defaultedIn arg);
+/*** Class that contains Small_explicit_explicit_defaultedIn ***/
+class Container_explicit_explicit_defaultedIn {
+public:
+  Small_explicit_explicit_defaultedIn item;
+};
+
+Container_explicit_explicit_defaultedIn Container_explicit_explicit_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_explicit_explicit_defaultedIn> (Container_explicit_explicit_defaultedIn arg);
+/*** C++ class Small_explicit_explicit_defaultedOut ***/
+class Small_explicit_explicit_defaultedOut {
+public:
+  Small_explicit_explicit_defaultedOut (void);
+  Small_explicit_explicit_defaultedOut (const Small_explicit_explicit_defaultedOut &rhs);
+  ~Small_explicit_explicit_defaultedOut (void);
+  Small_explicit_explicit_defaultedOut (Small_explicit_explicit_defaultedOut &&rhs);
+
+
+  int data[2];
+};
+
+Small_explicit_explicit_defaultedOut::Small_explicit_explicit_defaultedOut (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_explicit_explicit_defaultedOut::Small_explicit_explicit_defaultedOut (const Small_explicit_explicit_defaultedOut &rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_explicit_explicit_defaultedOut::~Small_explicit_explicit_defaultedOut (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_explicit_explicit_defaultedOut::Small_explicit_explicit_defaultedOut (Small_explicit_explicit_defaultedOut &&rhs) = default;
+
+
+Small_explicit_explicit_defaultedOut Small_explicit_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Small_explicit_explicit_defaultedOut> (Small_explicit_explicit_defaultedOut arg);
+/*** C++ class Large_explicit_explicit_defaultedOut ***/
+class Large_explicit_explicit_defaultedOut {
+public:
+  Large_explicit_explicit_defaultedOut (void);
+  Large_explicit_explicit_defaultedOut (const Large_explicit_explicit_defaultedOut &rhs);
+  ~Large_explicit_explicit_defaultedOut (void);
+  Large_explicit_explicit_defaultedOut (Large_explicit_explicit_defaultedOut &&rhs);
+
+
+  int data[150];
+};
+
+Large_explicit_explicit_defaultedOut::Large_explicit_explicit_defaultedOut (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_explicit_explicit_defaultedOut::Large_explicit_explicit_defaultedOut (const Large_explicit_explicit_defaultedOut &rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_explicit_explicit_defaultedOut::~Large_explicit_explicit_defaultedOut (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_explicit_explicit_defaultedOut::Large_explicit_explicit_defaultedOut (Large_explicit_explicit_defaultedOut &&rhs) = default;
+
+
+Large_explicit_explicit_defaultedOut Large_explicit_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Large_explicit_explicit_defaultedOut> (Large_explicit_explicit_defaultedOut arg);
+/*** Class derived from Small_explicit_explicit_defaultedOut ***/
+class Derived_explicit_explicit_defaultedOut : public Small_explicit_explicit_defaultedOut {
+public:
+};
+
+Derived_explicit_explicit_defaultedOut Derived_explicit_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Derived_explicit_explicit_defaultedOut> (Derived_explicit_explicit_defaultedOut arg);
+/*** Class that contains Small_explicit_explicit_defaultedOut ***/
+class Container_explicit_explicit_defaultedOut {
+public:
+  Small_explicit_explicit_defaultedOut item;
+};
+
+Container_explicit_explicit_defaultedOut Container_explicit_explicit_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_explicit_explicit_defaultedOut> (Container_explicit_explicit_defaultedOut arg);
+/*** C++ class Small_explicit_explicit_deleted ***/
+class Small_explicit_explicit_deleted {
+public:
+  Small_explicit_explicit_deleted (void);
+  Small_explicit_explicit_deleted (const Small_explicit_explicit_deleted &rhs);
+  ~Small_explicit_explicit_deleted (void);
+  Small_explicit_explicit_deleted (Small_explicit_explicit_deleted &&rhs) = delete;
+
+
+  int data[2];
+};
+
+Small_explicit_explicit_deleted::Small_explicit_explicit_deleted (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_explicit_explicit_deleted::Small_explicit_explicit_deleted (const Small_explicit_explicit_deleted &rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_explicit_explicit_deleted::~Small_explicit_explicit_deleted (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_explicit_explicit_deleted Small_explicit_explicit_deleted_var; /* global var */
+
+template int cbv<Small_explicit_explicit_deleted> (Small_explicit_explicit_deleted arg);
+/*** C++ class Large_explicit_explicit_deleted ***/
+class Large_explicit_explicit_deleted {
+public:
+  Large_explicit_explicit_deleted (void);
+  Large_explicit_explicit_deleted (const Large_explicit_explicit_deleted &rhs);
+  ~Large_explicit_explicit_deleted (void);
+  Large_explicit_explicit_deleted (Large_explicit_explicit_deleted &&rhs) = delete;
+
+
+  int data[150];
+};
+
+Large_explicit_explicit_deleted::Large_explicit_explicit_deleted (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_explicit_explicit_deleted::Large_explicit_explicit_deleted (const Large_explicit_explicit_deleted &rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_explicit_explicit_deleted::~Large_explicit_explicit_deleted (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_explicit_explicit_deleted Large_explicit_explicit_deleted_var; /* global var */
+
+template int cbv<Large_explicit_explicit_deleted> (Large_explicit_explicit_deleted arg);
+/*** Class derived from Small_explicit_explicit_deleted ***/
+class Derived_explicit_explicit_deleted : public Small_explicit_explicit_deleted {
+public:
+};
+
+Derived_explicit_explicit_deleted Derived_explicit_explicit_deleted_var; /* global var */
+
+template int cbv<Derived_explicit_explicit_deleted> (Derived_explicit_explicit_deleted arg);
+/*** Class that contains Small_explicit_explicit_deleted ***/
+class Container_explicit_explicit_deleted {
+public:
+  Small_explicit_explicit_deleted item;
+};
+
+Container_explicit_explicit_deleted Container_explicit_explicit_deleted_var; /* global var */
+
+template int cbv_container<Container_explicit_explicit_deleted> (Container_explicit_explicit_deleted arg);
+/*** C++ class Small_explicit_defaultedIn_absent ***/
+class Small_explicit_defaultedIn_absent {
+public:
+  Small_explicit_defaultedIn_absent (void);
+  Small_explicit_defaultedIn_absent (const Small_explicit_defaultedIn_absent &rhs);
+  ~Small_explicit_defaultedIn_absent (void) = default;
+
+
+  int data[2];
+};
+
+Small_explicit_defaultedIn_absent::Small_explicit_defaultedIn_absent (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_explicit_defaultedIn_absent::Small_explicit_defaultedIn_absent (const Small_explicit_defaultedIn_absent &rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_explicit_defaultedIn_absent Small_explicit_defaultedIn_absent_var; /* global var */
+
+template int cbv<Small_explicit_defaultedIn_absent> (Small_explicit_defaultedIn_absent arg);
+/*** C++ class Large_explicit_defaultedIn_absent ***/
+class Large_explicit_defaultedIn_absent {
+public:
+  Large_explicit_defaultedIn_absent (void);
+  Large_explicit_defaultedIn_absent (const Large_explicit_defaultedIn_absent &rhs);
+  ~Large_explicit_defaultedIn_absent (void) = default;
+
+
+  int data[150];
+};
+
+Large_explicit_defaultedIn_absent::Large_explicit_defaultedIn_absent (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_explicit_defaultedIn_absent::Large_explicit_defaultedIn_absent (const Large_explicit_defaultedIn_absent &rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_explicit_defaultedIn_absent Large_explicit_defaultedIn_absent_var; /* global var */
+
+template int cbv<Large_explicit_defaultedIn_absent> (Large_explicit_defaultedIn_absent arg);
+/*** Class derived from Small_explicit_defaultedIn_absent ***/
+class Derived_explicit_defaultedIn_absent : public Small_explicit_defaultedIn_absent {
+public:
+};
+
+Derived_explicit_defaultedIn_absent Derived_explicit_defaultedIn_absent_var; /* global var */
+
+template int cbv<Derived_explicit_defaultedIn_absent> (Derived_explicit_defaultedIn_absent arg);
+/*** Class that contains Small_explicit_defaultedIn_absent ***/
+class Container_explicit_defaultedIn_absent {
+public:
+  Small_explicit_defaultedIn_absent item;
+};
+
+Container_explicit_defaultedIn_absent Container_explicit_defaultedIn_absent_var; /* global var */
+
+template int cbv_container<Container_explicit_defaultedIn_absent> (Container_explicit_defaultedIn_absent arg);
+/*** C++ class Small_explicit_defaultedIn_explicit ***/
+class Small_explicit_defaultedIn_explicit {
+public:
+  Small_explicit_defaultedIn_explicit (void);
+  Small_explicit_defaultedIn_explicit (const Small_explicit_defaultedIn_explicit &rhs);
+  ~Small_explicit_defaultedIn_explicit (void) = default;
+  Small_explicit_defaultedIn_explicit (Small_explicit_defaultedIn_explicit &&rhs);
+
+
+  int data[2];
+};
+
+Small_explicit_defaultedIn_explicit::Small_explicit_defaultedIn_explicit (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_explicit_defaultedIn_explicit::Small_explicit_defaultedIn_explicit (const Small_explicit_defaultedIn_explicit &rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_explicit_defaultedIn_explicit::Small_explicit_defaultedIn_explicit (Small_explicit_defaultedIn_explicit &&rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_explicit_defaultedIn_explicit Small_explicit_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Small_explicit_defaultedIn_explicit> (Small_explicit_defaultedIn_explicit arg);
+/*** C++ class Large_explicit_defaultedIn_explicit ***/
+class Large_explicit_defaultedIn_explicit {
+public:
+  Large_explicit_defaultedIn_explicit (void);
+  Large_explicit_defaultedIn_explicit (const Large_explicit_defaultedIn_explicit &rhs);
+  ~Large_explicit_defaultedIn_explicit (void) = default;
+  Large_explicit_defaultedIn_explicit (Large_explicit_defaultedIn_explicit &&rhs);
+
+
+  int data[150];
+};
+
+Large_explicit_defaultedIn_explicit::Large_explicit_defaultedIn_explicit (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_explicit_defaultedIn_explicit::Large_explicit_defaultedIn_explicit (const Large_explicit_defaultedIn_explicit &rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_explicit_defaultedIn_explicit::Large_explicit_defaultedIn_explicit (Large_explicit_defaultedIn_explicit &&rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_explicit_defaultedIn_explicit Large_explicit_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Large_explicit_defaultedIn_explicit> (Large_explicit_defaultedIn_explicit arg);
+/*** Class derived from Small_explicit_defaultedIn_explicit ***/
+class Derived_explicit_defaultedIn_explicit : public Small_explicit_defaultedIn_explicit {
+public:
+};
+
+Derived_explicit_defaultedIn_explicit Derived_explicit_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Derived_explicit_defaultedIn_explicit> (Derived_explicit_defaultedIn_explicit arg);
+/*** Class that contains Small_explicit_defaultedIn_explicit ***/
+class Container_explicit_defaultedIn_explicit {
+public:
+  Small_explicit_defaultedIn_explicit item;
+};
+
+Container_explicit_defaultedIn_explicit Container_explicit_defaultedIn_explicit_var; /* global var */
+
+template int cbv_container<Container_explicit_defaultedIn_explicit> (Container_explicit_defaultedIn_explicit arg);
+/*** C++ class Small_explicit_defaultedIn_defaultedIn ***/
+class Small_explicit_defaultedIn_defaultedIn {
+public:
+  Small_explicit_defaultedIn_defaultedIn (void);
+  Small_explicit_defaultedIn_defaultedIn (const Small_explicit_defaultedIn_defaultedIn &rhs);
+  ~Small_explicit_defaultedIn_defaultedIn (void) = default;
+  Small_explicit_defaultedIn_defaultedIn (Small_explicit_defaultedIn_defaultedIn &&rhs) = default;
+
+
+  int data[2];
+};
+
+Small_explicit_defaultedIn_defaultedIn::Small_explicit_defaultedIn_defaultedIn (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_explicit_defaultedIn_defaultedIn::Small_explicit_defaultedIn_defaultedIn (const Small_explicit_defaultedIn_defaultedIn &rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_explicit_defaultedIn_defaultedIn Small_explicit_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Small_explicit_defaultedIn_defaultedIn> (Small_explicit_defaultedIn_defaultedIn arg);
+/*** C++ class Large_explicit_defaultedIn_defaultedIn ***/
+class Large_explicit_defaultedIn_defaultedIn {
+public:
+  Large_explicit_defaultedIn_defaultedIn (void);
+  Large_explicit_defaultedIn_defaultedIn (const Large_explicit_defaultedIn_defaultedIn &rhs);
+  ~Large_explicit_defaultedIn_defaultedIn (void) = default;
+  Large_explicit_defaultedIn_defaultedIn (Large_explicit_defaultedIn_defaultedIn &&rhs) = default;
+
+
+  int data[150];
+};
+
+Large_explicit_defaultedIn_defaultedIn::Large_explicit_defaultedIn_defaultedIn (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_explicit_defaultedIn_defaultedIn::Large_explicit_defaultedIn_defaultedIn (const Large_explicit_defaultedIn_defaultedIn &rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_explicit_defaultedIn_defaultedIn Large_explicit_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Large_explicit_defaultedIn_defaultedIn> (Large_explicit_defaultedIn_defaultedIn arg);
+/*** Class derived from Small_explicit_defaultedIn_defaultedIn ***/
+class Derived_explicit_defaultedIn_defaultedIn : public Small_explicit_defaultedIn_defaultedIn {
+public:
+};
+
+Derived_explicit_defaultedIn_defaultedIn Derived_explicit_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Derived_explicit_defaultedIn_defaultedIn> (Derived_explicit_defaultedIn_defaultedIn arg);
+/*** Class that contains Small_explicit_defaultedIn_defaultedIn ***/
+class Container_explicit_defaultedIn_defaultedIn {
+public:
+  Small_explicit_defaultedIn_defaultedIn item;
+};
+
+Container_explicit_defaultedIn_defaultedIn Container_explicit_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_explicit_defaultedIn_defaultedIn> (Container_explicit_defaultedIn_defaultedIn arg);
+/*** C++ class Small_explicit_defaultedIn_defaultedOut ***/
+class Small_explicit_defaultedIn_defaultedOut {
+public:
+  Small_explicit_defaultedIn_defaultedOut (void);
+  Small_explicit_defaultedIn_defaultedOut (const Small_explicit_defaultedIn_defaultedOut &rhs);
+  ~Small_explicit_defaultedIn_defaultedOut (void) = default;
+  Small_explicit_defaultedIn_defaultedOut (Small_explicit_defaultedIn_defaultedOut &&rhs);
+
+
+  int data[2];
+};
+
+Small_explicit_defaultedIn_defaultedOut::Small_explicit_defaultedIn_defaultedOut (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_explicit_defaultedIn_defaultedOut::Small_explicit_defaultedIn_defaultedOut (const Small_explicit_defaultedIn_defaultedOut &rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_explicit_defaultedIn_defaultedOut::Small_explicit_defaultedIn_defaultedOut (Small_explicit_defaultedIn_defaultedOut &&rhs) = default;
+
+
+Small_explicit_defaultedIn_defaultedOut Small_explicit_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Small_explicit_defaultedIn_defaultedOut> (Small_explicit_defaultedIn_defaultedOut arg);
+/*** C++ class Large_explicit_defaultedIn_defaultedOut ***/
+class Large_explicit_defaultedIn_defaultedOut {
+public:
+  Large_explicit_defaultedIn_defaultedOut (void);
+  Large_explicit_defaultedIn_defaultedOut (const Large_explicit_defaultedIn_defaultedOut &rhs);
+  ~Large_explicit_defaultedIn_defaultedOut (void) = default;
+  Large_explicit_defaultedIn_defaultedOut (Large_explicit_defaultedIn_defaultedOut &&rhs);
+
+
+  int data[150];
+};
+
+Large_explicit_defaultedIn_defaultedOut::Large_explicit_defaultedIn_defaultedOut (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_explicit_defaultedIn_defaultedOut::Large_explicit_defaultedIn_defaultedOut (const Large_explicit_defaultedIn_defaultedOut &rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_explicit_defaultedIn_defaultedOut::Large_explicit_defaultedIn_defaultedOut (Large_explicit_defaultedIn_defaultedOut &&rhs) = default;
+
+
+Large_explicit_defaultedIn_defaultedOut Large_explicit_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Large_explicit_defaultedIn_defaultedOut> (Large_explicit_defaultedIn_defaultedOut arg);
+/*** Class derived from Small_explicit_defaultedIn_defaultedOut ***/
+class Derived_explicit_defaultedIn_defaultedOut : public Small_explicit_defaultedIn_defaultedOut {
+public:
+};
+
+Derived_explicit_defaultedIn_defaultedOut Derived_explicit_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Derived_explicit_defaultedIn_defaultedOut> (Derived_explicit_defaultedIn_defaultedOut arg);
+/*** Class that contains Small_explicit_defaultedIn_defaultedOut ***/
+class Container_explicit_defaultedIn_defaultedOut {
+public:
+  Small_explicit_defaultedIn_defaultedOut item;
+};
+
+Container_explicit_defaultedIn_defaultedOut Container_explicit_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_explicit_defaultedIn_defaultedOut> (Container_explicit_defaultedIn_defaultedOut arg);
+/*** C++ class Small_explicit_defaultedIn_deleted ***/
+class Small_explicit_defaultedIn_deleted {
+public:
+  Small_explicit_defaultedIn_deleted (void);
+  Small_explicit_defaultedIn_deleted (const Small_explicit_defaultedIn_deleted &rhs);
+  ~Small_explicit_defaultedIn_deleted (void) = default;
+  Small_explicit_defaultedIn_deleted (Small_explicit_defaultedIn_deleted &&rhs) = delete;
+
+
+  int data[2];
+};
+
+Small_explicit_defaultedIn_deleted::Small_explicit_defaultedIn_deleted (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_explicit_defaultedIn_deleted::Small_explicit_defaultedIn_deleted (const Small_explicit_defaultedIn_deleted &rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_explicit_defaultedIn_deleted Small_explicit_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Small_explicit_defaultedIn_deleted> (Small_explicit_defaultedIn_deleted arg);
+/*** C++ class Large_explicit_defaultedIn_deleted ***/
+class Large_explicit_defaultedIn_deleted {
+public:
+  Large_explicit_defaultedIn_deleted (void);
+  Large_explicit_defaultedIn_deleted (const Large_explicit_defaultedIn_deleted &rhs);
+  ~Large_explicit_defaultedIn_deleted (void) = default;
+  Large_explicit_defaultedIn_deleted (Large_explicit_defaultedIn_deleted &&rhs) = delete;
+
+
+  int data[150];
+};
+
+Large_explicit_defaultedIn_deleted::Large_explicit_defaultedIn_deleted (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_explicit_defaultedIn_deleted::Large_explicit_defaultedIn_deleted (const Large_explicit_defaultedIn_deleted &rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_explicit_defaultedIn_deleted Large_explicit_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Large_explicit_defaultedIn_deleted> (Large_explicit_defaultedIn_deleted arg);
+/*** Class derived from Small_explicit_defaultedIn_deleted ***/
+class Derived_explicit_defaultedIn_deleted : public Small_explicit_defaultedIn_deleted {
+public:
+};
+
+Derived_explicit_defaultedIn_deleted Derived_explicit_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Derived_explicit_defaultedIn_deleted> (Derived_explicit_defaultedIn_deleted arg);
+/*** Class that contains Small_explicit_defaultedIn_deleted ***/
+class Container_explicit_defaultedIn_deleted {
+public:
+  Small_explicit_defaultedIn_deleted item;
+};
+
+Container_explicit_defaultedIn_deleted Container_explicit_defaultedIn_deleted_var; /* global var */
+
+template int cbv_container<Container_explicit_defaultedIn_deleted> (Container_explicit_defaultedIn_deleted arg);
+/*** C++ class Small_explicit_defaultedOut_absent ***/
+class Small_explicit_defaultedOut_absent {
+public:
+  Small_explicit_defaultedOut_absent (void);
+  Small_explicit_defaultedOut_absent (const Small_explicit_defaultedOut_absent &rhs);
+  ~Small_explicit_defaultedOut_absent (void);
+
+
+  int data[2];
+};
+
+Small_explicit_defaultedOut_absent::Small_explicit_defaultedOut_absent (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_explicit_defaultedOut_absent::Small_explicit_defaultedOut_absent (const Small_explicit_defaultedOut_absent &rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_explicit_defaultedOut_absent::~Small_explicit_defaultedOut_absent (void) = default;
+
+
+Small_explicit_defaultedOut_absent Small_explicit_defaultedOut_absent_var; /* global var */
+
+template int cbv<Small_explicit_defaultedOut_absent> (Small_explicit_defaultedOut_absent arg);
+/*** C++ class Large_explicit_defaultedOut_absent ***/
+class Large_explicit_defaultedOut_absent {
+public:
+  Large_explicit_defaultedOut_absent (void);
+  Large_explicit_defaultedOut_absent (const Large_explicit_defaultedOut_absent &rhs);
+  ~Large_explicit_defaultedOut_absent (void);
+
+
+  int data[150];
+};
+
+Large_explicit_defaultedOut_absent::Large_explicit_defaultedOut_absent (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_explicit_defaultedOut_absent::Large_explicit_defaultedOut_absent (const Large_explicit_defaultedOut_absent &rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_explicit_defaultedOut_absent::~Large_explicit_defaultedOut_absent (void) = default;
+
+
+Large_explicit_defaultedOut_absent Large_explicit_defaultedOut_absent_var; /* global var */
+
+template int cbv<Large_explicit_defaultedOut_absent> (Large_explicit_defaultedOut_absent arg);
+/*** Class derived from Small_explicit_defaultedOut_absent ***/
+class Derived_explicit_defaultedOut_absent : public Small_explicit_defaultedOut_absent {
+public:
+};
+
+Derived_explicit_defaultedOut_absent Derived_explicit_defaultedOut_absent_var; /* global var */
+
+template int cbv<Derived_explicit_defaultedOut_absent> (Derived_explicit_defaultedOut_absent arg);
+/*** Class that contains Small_explicit_defaultedOut_absent ***/
+class Container_explicit_defaultedOut_absent {
+public:
+  Small_explicit_defaultedOut_absent item;
+};
+
+Container_explicit_defaultedOut_absent Container_explicit_defaultedOut_absent_var; /* global var */
+
+template int cbv_container<Container_explicit_defaultedOut_absent> (Container_explicit_defaultedOut_absent arg);
+/*** C++ class Small_explicit_defaultedOut_explicit ***/
+class Small_explicit_defaultedOut_explicit {
+public:
+  Small_explicit_defaultedOut_explicit (void);
+  Small_explicit_defaultedOut_explicit (const Small_explicit_defaultedOut_explicit &rhs);
+  ~Small_explicit_defaultedOut_explicit (void);
+  Small_explicit_defaultedOut_explicit (Small_explicit_defaultedOut_explicit &&rhs);
+
+
+  int data[2];
+};
+
+Small_explicit_defaultedOut_explicit::Small_explicit_defaultedOut_explicit (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_explicit_defaultedOut_explicit::Small_explicit_defaultedOut_explicit (const Small_explicit_defaultedOut_explicit &rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_explicit_defaultedOut_explicit::~Small_explicit_defaultedOut_explicit (void) = default;
+Small_explicit_defaultedOut_explicit::Small_explicit_defaultedOut_explicit (Small_explicit_defaultedOut_explicit &&rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_explicit_defaultedOut_explicit Small_explicit_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Small_explicit_defaultedOut_explicit> (Small_explicit_defaultedOut_explicit arg);
+/*** C++ class Large_explicit_defaultedOut_explicit ***/
+class Large_explicit_defaultedOut_explicit {
+public:
+  Large_explicit_defaultedOut_explicit (void);
+  Large_explicit_defaultedOut_explicit (const Large_explicit_defaultedOut_explicit &rhs);
+  ~Large_explicit_defaultedOut_explicit (void);
+  Large_explicit_defaultedOut_explicit (Large_explicit_defaultedOut_explicit &&rhs);
+
+
+  int data[150];
+};
+
+Large_explicit_defaultedOut_explicit::Large_explicit_defaultedOut_explicit (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_explicit_defaultedOut_explicit::Large_explicit_defaultedOut_explicit (const Large_explicit_defaultedOut_explicit &rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_explicit_defaultedOut_explicit::~Large_explicit_defaultedOut_explicit (void) = default;
+Large_explicit_defaultedOut_explicit::Large_explicit_defaultedOut_explicit (Large_explicit_defaultedOut_explicit &&rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_explicit_defaultedOut_explicit Large_explicit_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Large_explicit_defaultedOut_explicit> (Large_explicit_defaultedOut_explicit arg);
+/*** Class derived from Small_explicit_defaultedOut_explicit ***/
+class Derived_explicit_defaultedOut_explicit : public Small_explicit_defaultedOut_explicit {
+public:
+};
+
+Derived_explicit_defaultedOut_explicit Derived_explicit_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Derived_explicit_defaultedOut_explicit> (Derived_explicit_defaultedOut_explicit arg);
+/*** Class that contains Small_explicit_defaultedOut_explicit ***/
+class Container_explicit_defaultedOut_explicit {
+public:
+  Small_explicit_defaultedOut_explicit item;
+};
+
+Container_explicit_defaultedOut_explicit Container_explicit_defaultedOut_explicit_var; /* global var */
+
+template int cbv_container<Container_explicit_defaultedOut_explicit> (Container_explicit_defaultedOut_explicit arg);
+/*** C++ class Small_explicit_defaultedOut_defaultedIn ***/
+class Small_explicit_defaultedOut_defaultedIn {
+public:
+  Small_explicit_defaultedOut_defaultedIn (void);
+  Small_explicit_defaultedOut_defaultedIn (const Small_explicit_defaultedOut_defaultedIn &rhs);
+  ~Small_explicit_defaultedOut_defaultedIn (void);
+  Small_explicit_defaultedOut_defaultedIn (Small_explicit_defaultedOut_defaultedIn &&rhs) = default;
+
+
+  int data[2];
+};
+
+Small_explicit_defaultedOut_defaultedIn::Small_explicit_defaultedOut_defaultedIn (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_explicit_defaultedOut_defaultedIn::Small_explicit_defaultedOut_defaultedIn (const Small_explicit_defaultedOut_defaultedIn &rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_explicit_defaultedOut_defaultedIn::~Small_explicit_defaultedOut_defaultedIn (void) = default;
+
+
+Small_explicit_defaultedOut_defaultedIn Small_explicit_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Small_explicit_defaultedOut_defaultedIn> (Small_explicit_defaultedOut_defaultedIn arg);
+/*** C++ class Large_explicit_defaultedOut_defaultedIn ***/
+class Large_explicit_defaultedOut_defaultedIn {
+public:
+  Large_explicit_defaultedOut_defaultedIn (void);
+  Large_explicit_defaultedOut_defaultedIn (const Large_explicit_defaultedOut_defaultedIn &rhs);
+  ~Large_explicit_defaultedOut_defaultedIn (void);
+  Large_explicit_defaultedOut_defaultedIn (Large_explicit_defaultedOut_defaultedIn &&rhs) = default;
+
+
+  int data[150];
+};
+
+Large_explicit_defaultedOut_defaultedIn::Large_explicit_defaultedOut_defaultedIn (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_explicit_defaultedOut_defaultedIn::Large_explicit_defaultedOut_defaultedIn (const Large_explicit_defaultedOut_defaultedIn &rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_explicit_defaultedOut_defaultedIn::~Large_explicit_defaultedOut_defaultedIn (void) = default;
+
+
+Large_explicit_defaultedOut_defaultedIn Large_explicit_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Large_explicit_defaultedOut_defaultedIn> (Large_explicit_defaultedOut_defaultedIn arg);
+/*** Class derived from Small_explicit_defaultedOut_defaultedIn ***/
+class Derived_explicit_defaultedOut_defaultedIn : public Small_explicit_defaultedOut_defaultedIn {
+public:
+};
+
+Derived_explicit_defaultedOut_defaultedIn Derived_explicit_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Derived_explicit_defaultedOut_defaultedIn> (Derived_explicit_defaultedOut_defaultedIn arg);
+/*** Class that contains Small_explicit_defaultedOut_defaultedIn ***/
+class Container_explicit_defaultedOut_defaultedIn {
+public:
+  Small_explicit_defaultedOut_defaultedIn item;
+};
+
+Container_explicit_defaultedOut_defaultedIn Container_explicit_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_explicit_defaultedOut_defaultedIn> (Container_explicit_defaultedOut_defaultedIn arg);
+/*** C++ class Small_explicit_defaultedOut_defaultedOut ***/
+class Small_explicit_defaultedOut_defaultedOut {
+public:
+  Small_explicit_defaultedOut_defaultedOut (void);
+  Small_explicit_defaultedOut_defaultedOut (const Small_explicit_defaultedOut_defaultedOut &rhs);
+  ~Small_explicit_defaultedOut_defaultedOut (void);
+  Small_explicit_defaultedOut_defaultedOut (Small_explicit_defaultedOut_defaultedOut &&rhs);
+
+
+  int data[2];
+};
+
+Small_explicit_defaultedOut_defaultedOut::Small_explicit_defaultedOut_defaultedOut (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_explicit_defaultedOut_defaultedOut::Small_explicit_defaultedOut_defaultedOut (const Small_explicit_defaultedOut_defaultedOut &rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_explicit_defaultedOut_defaultedOut::~Small_explicit_defaultedOut_defaultedOut (void) = default;
+Small_explicit_defaultedOut_defaultedOut::Small_explicit_defaultedOut_defaultedOut (Small_explicit_defaultedOut_defaultedOut &&rhs) = default;
+
+
+Small_explicit_defaultedOut_defaultedOut Small_explicit_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Small_explicit_defaultedOut_defaultedOut> (Small_explicit_defaultedOut_defaultedOut arg);
+/*** C++ class Large_explicit_defaultedOut_defaultedOut ***/
+class Large_explicit_defaultedOut_defaultedOut {
+public:
+  Large_explicit_defaultedOut_defaultedOut (void);
+  Large_explicit_defaultedOut_defaultedOut (const Large_explicit_defaultedOut_defaultedOut &rhs);
+  ~Large_explicit_defaultedOut_defaultedOut (void);
+  Large_explicit_defaultedOut_defaultedOut (Large_explicit_defaultedOut_defaultedOut &&rhs);
+
+
+  int data[150];
+};
+
+Large_explicit_defaultedOut_defaultedOut::Large_explicit_defaultedOut_defaultedOut (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_explicit_defaultedOut_defaultedOut::Large_explicit_defaultedOut_defaultedOut (const Large_explicit_defaultedOut_defaultedOut &rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_explicit_defaultedOut_defaultedOut::~Large_explicit_defaultedOut_defaultedOut (void) = default;
+Large_explicit_defaultedOut_defaultedOut::Large_explicit_defaultedOut_defaultedOut (Large_explicit_defaultedOut_defaultedOut &&rhs) = default;
+
+
+Large_explicit_defaultedOut_defaultedOut Large_explicit_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Large_explicit_defaultedOut_defaultedOut> (Large_explicit_defaultedOut_defaultedOut arg);
+/*** Class derived from Small_explicit_defaultedOut_defaultedOut ***/
+class Derived_explicit_defaultedOut_defaultedOut : public Small_explicit_defaultedOut_defaultedOut {
+public:
+};
+
+Derived_explicit_defaultedOut_defaultedOut Derived_explicit_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Derived_explicit_defaultedOut_defaultedOut> (Derived_explicit_defaultedOut_defaultedOut arg);
+/*** Class that contains Small_explicit_defaultedOut_defaultedOut ***/
+class Container_explicit_defaultedOut_defaultedOut {
+public:
+  Small_explicit_defaultedOut_defaultedOut item;
+};
+
+Container_explicit_defaultedOut_defaultedOut Container_explicit_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_explicit_defaultedOut_defaultedOut> (Container_explicit_defaultedOut_defaultedOut arg);
+/*** C++ class Small_explicit_defaultedOut_deleted ***/
+class Small_explicit_defaultedOut_deleted {
+public:
+  Small_explicit_defaultedOut_deleted (void);
+  Small_explicit_defaultedOut_deleted (const Small_explicit_defaultedOut_deleted &rhs);
+  ~Small_explicit_defaultedOut_deleted (void);
+  Small_explicit_defaultedOut_deleted (Small_explicit_defaultedOut_deleted &&rhs) = delete;
+
+
+  int data[2];
+};
+
+Small_explicit_defaultedOut_deleted::Small_explicit_defaultedOut_deleted (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_explicit_defaultedOut_deleted::Small_explicit_defaultedOut_deleted (const Small_explicit_defaultedOut_deleted &rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_explicit_defaultedOut_deleted::~Small_explicit_defaultedOut_deleted (void) = default;
+
+
+Small_explicit_defaultedOut_deleted Small_explicit_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Small_explicit_defaultedOut_deleted> (Small_explicit_defaultedOut_deleted arg);
+/*** C++ class Large_explicit_defaultedOut_deleted ***/
+class Large_explicit_defaultedOut_deleted {
+public:
+  Large_explicit_defaultedOut_deleted (void);
+  Large_explicit_defaultedOut_deleted (const Large_explicit_defaultedOut_deleted &rhs);
+  ~Large_explicit_defaultedOut_deleted (void);
+  Large_explicit_defaultedOut_deleted (Large_explicit_defaultedOut_deleted &&rhs) = delete;
+
+
+  int data[150];
+};
+
+Large_explicit_defaultedOut_deleted::Large_explicit_defaultedOut_deleted (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_explicit_defaultedOut_deleted::Large_explicit_defaultedOut_deleted (const Large_explicit_defaultedOut_deleted &rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_explicit_defaultedOut_deleted::~Large_explicit_defaultedOut_deleted (void) = default;
+
+
+Large_explicit_defaultedOut_deleted Large_explicit_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Large_explicit_defaultedOut_deleted> (Large_explicit_defaultedOut_deleted arg);
+/*** Class derived from Small_explicit_defaultedOut_deleted ***/
+class Derived_explicit_defaultedOut_deleted : public Small_explicit_defaultedOut_deleted {
+public:
+};
+
+Derived_explicit_defaultedOut_deleted Derived_explicit_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Derived_explicit_defaultedOut_deleted> (Derived_explicit_defaultedOut_deleted arg);
+/*** Class that contains Small_explicit_defaultedOut_deleted ***/
+class Container_explicit_defaultedOut_deleted {
+public:
+  Small_explicit_defaultedOut_deleted item;
+};
+
+Container_explicit_defaultedOut_deleted Container_explicit_defaultedOut_deleted_var; /* global var */
+
+template int cbv_container<Container_explicit_defaultedOut_deleted> (Container_explicit_defaultedOut_deleted arg);
+/*** C++ class Small_defaultedIn_absent_absent ***/
+class Small_defaultedIn_absent_absent {
+public:
+  Small_defaultedIn_absent_absent (void);
+  Small_defaultedIn_absent_absent (const Small_defaultedIn_absent_absent &rhs) = default;
+
+
+  int data[2];
+};
+
+Small_defaultedIn_absent_absent::Small_defaultedIn_absent_absent (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+
+
+Small_defaultedIn_absent_absent Small_defaultedIn_absent_absent_var; /* global var */
+
+template int cbv<Small_defaultedIn_absent_absent> (Small_defaultedIn_absent_absent arg);
+/*** C++ class Large_defaultedIn_absent_absent ***/
+class Large_defaultedIn_absent_absent {
+public:
+  Large_defaultedIn_absent_absent (void);
+  Large_defaultedIn_absent_absent (const Large_defaultedIn_absent_absent &rhs) = default;
+
+
+  int data[150];
+};
+
+Large_defaultedIn_absent_absent::Large_defaultedIn_absent_absent (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+
+
+Large_defaultedIn_absent_absent Large_defaultedIn_absent_absent_var; /* global var */
+
+template int cbv<Large_defaultedIn_absent_absent> (Large_defaultedIn_absent_absent arg);
+/*** Class derived from Small_defaultedIn_absent_absent ***/
+class Derived_defaultedIn_absent_absent : public Small_defaultedIn_absent_absent {
+public:
+};
+
+Derived_defaultedIn_absent_absent Derived_defaultedIn_absent_absent_var; /* global var */
+
+template int cbv<Derived_defaultedIn_absent_absent> (Derived_defaultedIn_absent_absent arg);
+/*** Class that contains Small_defaultedIn_absent_absent ***/
+class Container_defaultedIn_absent_absent {
+public:
+  Small_defaultedIn_absent_absent item;
+};
+
+Container_defaultedIn_absent_absent Container_defaultedIn_absent_absent_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_absent_absent> (Container_defaultedIn_absent_absent arg);
+/*** C++ class Small_defaultedIn_absent_explicit ***/
+class Small_defaultedIn_absent_explicit {
+public:
+  Small_defaultedIn_absent_explicit (void);
+  Small_defaultedIn_absent_explicit (const Small_defaultedIn_absent_explicit &rhs) = default;
+  Small_defaultedIn_absent_explicit (Small_defaultedIn_absent_explicit &&rhs);
+
+
+  int data[2];
+};
+
+Small_defaultedIn_absent_explicit::Small_defaultedIn_absent_explicit (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedIn_absent_explicit::Small_defaultedIn_absent_explicit (Small_defaultedIn_absent_explicit &&rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_defaultedIn_absent_explicit Small_defaultedIn_absent_explicit_var; /* global var */
+
+template int cbv<Small_defaultedIn_absent_explicit> (Small_defaultedIn_absent_explicit arg);
+/*** C++ class Large_defaultedIn_absent_explicit ***/
+class Large_defaultedIn_absent_explicit {
+public:
+  Large_defaultedIn_absent_explicit (void);
+  Large_defaultedIn_absent_explicit (const Large_defaultedIn_absent_explicit &rhs) = default;
+  Large_defaultedIn_absent_explicit (Large_defaultedIn_absent_explicit &&rhs);
+
+
+  int data[150];
+};
+
+Large_defaultedIn_absent_explicit::Large_defaultedIn_absent_explicit (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedIn_absent_explicit::Large_defaultedIn_absent_explicit (Large_defaultedIn_absent_explicit &&rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_defaultedIn_absent_explicit Large_defaultedIn_absent_explicit_var; /* global var */
+
+template int cbv<Large_defaultedIn_absent_explicit> (Large_defaultedIn_absent_explicit arg);
+/*** Class derived from Small_defaultedIn_absent_explicit ***/
+class Derived_defaultedIn_absent_explicit : public Small_defaultedIn_absent_explicit {
+public:
+};
+
+Derived_defaultedIn_absent_explicit Derived_defaultedIn_absent_explicit_var; /* global var */
+
+template int cbv<Derived_defaultedIn_absent_explicit> (Derived_defaultedIn_absent_explicit arg);
+/*** Class that contains Small_defaultedIn_absent_explicit ***/
+class Container_defaultedIn_absent_explicit {
+public:
+  Small_defaultedIn_absent_explicit item;
+};
+
+Container_defaultedIn_absent_explicit Container_defaultedIn_absent_explicit_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_absent_explicit> (Container_defaultedIn_absent_explicit arg);
+/*** C++ class Small_defaultedIn_absent_defaultedIn ***/
+class Small_defaultedIn_absent_defaultedIn {
+public:
+  Small_defaultedIn_absent_defaultedIn (void);
+  Small_defaultedIn_absent_defaultedIn (const Small_defaultedIn_absent_defaultedIn &rhs) = default;
+  Small_defaultedIn_absent_defaultedIn (Small_defaultedIn_absent_defaultedIn &&rhs) = default;
+
+
+  int data[2];
+};
+
+Small_defaultedIn_absent_defaultedIn::Small_defaultedIn_absent_defaultedIn (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+
+
+Small_defaultedIn_absent_defaultedIn Small_defaultedIn_absent_defaultedIn_var; /* global var */
+
+template int cbv<Small_defaultedIn_absent_defaultedIn> (Small_defaultedIn_absent_defaultedIn arg);
+/*** C++ class Large_defaultedIn_absent_defaultedIn ***/
+class Large_defaultedIn_absent_defaultedIn {
+public:
+  Large_defaultedIn_absent_defaultedIn (void);
+  Large_defaultedIn_absent_defaultedIn (const Large_defaultedIn_absent_defaultedIn &rhs) = default;
+  Large_defaultedIn_absent_defaultedIn (Large_defaultedIn_absent_defaultedIn &&rhs) = default;
+
+
+  int data[150];
+};
+
+Large_defaultedIn_absent_defaultedIn::Large_defaultedIn_absent_defaultedIn (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+
+
+Large_defaultedIn_absent_defaultedIn Large_defaultedIn_absent_defaultedIn_var; /* global var */
+
+template int cbv<Large_defaultedIn_absent_defaultedIn> (Large_defaultedIn_absent_defaultedIn arg);
+/*** Class derived from Small_defaultedIn_absent_defaultedIn ***/
+class Derived_defaultedIn_absent_defaultedIn : public Small_defaultedIn_absent_defaultedIn {
+public:
+};
+
+Derived_defaultedIn_absent_defaultedIn Derived_defaultedIn_absent_defaultedIn_var; /* global var */
+
+template int cbv<Derived_defaultedIn_absent_defaultedIn> (Derived_defaultedIn_absent_defaultedIn arg);
+/*** Class that contains Small_defaultedIn_absent_defaultedIn ***/
+class Container_defaultedIn_absent_defaultedIn {
+public:
+  Small_defaultedIn_absent_defaultedIn item;
+};
+
+Container_defaultedIn_absent_defaultedIn Container_defaultedIn_absent_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_absent_defaultedIn> (Container_defaultedIn_absent_defaultedIn arg);
+/*** C++ class Small_defaultedIn_absent_defaultedOut ***/
+class Small_defaultedIn_absent_defaultedOut {
+public:
+  Small_defaultedIn_absent_defaultedOut (void);
+  Small_defaultedIn_absent_defaultedOut (const Small_defaultedIn_absent_defaultedOut &rhs) = default;
+  Small_defaultedIn_absent_defaultedOut (Small_defaultedIn_absent_defaultedOut &&rhs);
+
+
+  int data[2];
+};
+
+Small_defaultedIn_absent_defaultedOut::Small_defaultedIn_absent_defaultedOut (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedIn_absent_defaultedOut::Small_defaultedIn_absent_defaultedOut (Small_defaultedIn_absent_defaultedOut &&rhs) = default;
+
+
+Small_defaultedIn_absent_defaultedOut Small_defaultedIn_absent_defaultedOut_var; /* global var */
+
+template int cbv<Small_defaultedIn_absent_defaultedOut> (Small_defaultedIn_absent_defaultedOut arg);
+/*** C++ class Large_defaultedIn_absent_defaultedOut ***/
+class Large_defaultedIn_absent_defaultedOut {
+public:
+  Large_defaultedIn_absent_defaultedOut (void);
+  Large_defaultedIn_absent_defaultedOut (const Large_defaultedIn_absent_defaultedOut &rhs) = default;
+  Large_defaultedIn_absent_defaultedOut (Large_defaultedIn_absent_defaultedOut &&rhs);
+
+
+  int data[150];
+};
+
+Large_defaultedIn_absent_defaultedOut::Large_defaultedIn_absent_defaultedOut (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedIn_absent_defaultedOut::Large_defaultedIn_absent_defaultedOut (Large_defaultedIn_absent_defaultedOut &&rhs) = default;
+
+
+Large_defaultedIn_absent_defaultedOut Large_defaultedIn_absent_defaultedOut_var; /* global var */
+
+template int cbv<Large_defaultedIn_absent_defaultedOut> (Large_defaultedIn_absent_defaultedOut arg);
+/*** Class derived from Small_defaultedIn_absent_defaultedOut ***/
+class Derived_defaultedIn_absent_defaultedOut : public Small_defaultedIn_absent_defaultedOut {
+public:
+};
+
+Derived_defaultedIn_absent_defaultedOut Derived_defaultedIn_absent_defaultedOut_var; /* global var */
+
+template int cbv<Derived_defaultedIn_absent_defaultedOut> (Derived_defaultedIn_absent_defaultedOut arg);
+/*** Class that contains Small_defaultedIn_absent_defaultedOut ***/
+class Container_defaultedIn_absent_defaultedOut {
+public:
+  Small_defaultedIn_absent_defaultedOut item;
+};
+
+Container_defaultedIn_absent_defaultedOut Container_defaultedIn_absent_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_absent_defaultedOut> (Container_defaultedIn_absent_defaultedOut arg);
+/*** C++ class Small_defaultedIn_absent_deleted ***/
+class Small_defaultedIn_absent_deleted {
+public:
+  Small_defaultedIn_absent_deleted (void);
+  Small_defaultedIn_absent_deleted (const Small_defaultedIn_absent_deleted &rhs) = default;
+  Small_defaultedIn_absent_deleted (Small_defaultedIn_absent_deleted &&rhs) = delete;
+
+
+  int data[2];
+};
+
+Small_defaultedIn_absent_deleted::Small_defaultedIn_absent_deleted (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+
+
+Small_defaultedIn_absent_deleted Small_defaultedIn_absent_deleted_var; /* global var */
+
+template int cbv<Small_defaultedIn_absent_deleted> (Small_defaultedIn_absent_deleted arg);
+/*** C++ class Large_defaultedIn_absent_deleted ***/
+class Large_defaultedIn_absent_deleted {
+public:
+  Large_defaultedIn_absent_deleted (void);
+  Large_defaultedIn_absent_deleted (const Large_defaultedIn_absent_deleted &rhs) = default;
+  Large_defaultedIn_absent_deleted (Large_defaultedIn_absent_deleted &&rhs) = delete;
+
+
+  int data[150];
+};
+
+Large_defaultedIn_absent_deleted::Large_defaultedIn_absent_deleted (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+
+
+Large_defaultedIn_absent_deleted Large_defaultedIn_absent_deleted_var; /* global var */
+
+template int cbv<Large_defaultedIn_absent_deleted> (Large_defaultedIn_absent_deleted arg);
+/*** Class derived from Small_defaultedIn_absent_deleted ***/
+class Derived_defaultedIn_absent_deleted : public Small_defaultedIn_absent_deleted {
+public:
+};
+
+Derived_defaultedIn_absent_deleted Derived_defaultedIn_absent_deleted_var; /* global var */
+
+template int cbv<Derived_defaultedIn_absent_deleted> (Derived_defaultedIn_absent_deleted arg);
+/*** Class that contains Small_defaultedIn_absent_deleted ***/
+class Container_defaultedIn_absent_deleted {
+public:
+  Small_defaultedIn_absent_deleted item;
+};
+
+Container_defaultedIn_absent_deleted Container_defaultedIn_absent_deleted_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_absent_deleted> (Container_defaultedIn_absent_deleted arg);
+/*** C++ class Small_defaultedIn_explicit_absent ***/
+class Small_defaultedIn_explicit_absent {
+public:
+  Small_defaultedIn_explicit_absent (void);
+  Small_defaultedIn_explicit_absent (const Small_defaultedIn_explicit_absent &rhs) = default;
+  ~Small_defaultedIn_explicit_absent (void);
+
+
+  int data[2];
+};
+
+Small_defaultedIn_explicit_absent::Small_defaultedIn_explicit_absent (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedIn_explicit_absent::~Small_defaultedIn_explicit_absent (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_defaultedIn_explicit_absent Small_defaultedIn_explicit_absent_var; /* global var */
+
+template int cbv<Small_defaultedIn_explicit_absent> (Small_defaultedIn_explicit_absent arg);
+/*** C++ class Large_defaultedIn_explicit_absent ***/
+class Large_defaultedIn_explicit_absent {
+public:
+  Large_defaultedIn_explicit_absent (void);
+  Large_defaultedIn_explicit_absent (const Large_defaultedIn_explicit_absent &rhs) = default;
+  ~Large_defaultedIn_explicit_absent (void);
+
+
+  int data[150];
+};
+
+Large_defaultedIn_explicit_absent::Large_defaultedIn_explicit_absent (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedIn_explicit_absent::~Large_defaultedIn_explicit_absent (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_defaultedIn_explicit_absent Large_defaultedIn_explicit_absent_var; /* global var */
+
+template int cbv<Large_defaultedIn_explicit_absent> (Large_defaultedIn_explicit_absent arg);
+/*** Class derived from Small_defaultedIn_explicit_absent ***/
+class Derived_defaultedIn_explicit_absent : public Small_defaultedIn_explicit_absent {
+public:
+};
+
+Derived_defaultedIn_explicit_absent Derived_defaultedIn_explicit_absent_var; /* global var */
+
+template int cbv<Derived_defaultedIn_explicit_absent> (Derived_defaultedIn_explicit_absent arg);
+/*** Class that contains Small_defaultedIn_explicit_absent ***/
+class Container_defaultedIn_explicit_absent {
+public:
+  Small_defaultedIn_explicit_absent item;
+};
+
+Container_defaultedIn_explicit_absent Container_defaultedIn_explicit_absent_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_explicit_absent> (Container_defaultedIn_explicit_absent arg);
+/*** C++ class Small_defaultedIn_explicit_explicit ***/
+class Small_defaultedIn_explicit_explicit {
+public:
+  Small_defaultedIn_explicit_explicit (void);
+  Small_defaultedIn_explicit_explicit (const Small_defaultedIn_explicit_explicit &rhs) = default;
+  ~Small_defaultedIn_explicit_explicit (void);
+  Small_defaultedIn_explicit_explicit (Small_defaultedIn_explicit_explicit &&rhs);
+
+
+  int data[2];
+};
+
+Small_defaultedIn_explicit_explicit::Small_defaultedIn_explicit_explicit (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedIn_explicit_explicit::~Small_defaultedIn_explicit_explicit (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_defaultedIn_explicit_explicit::Small_defaultedIn_explicit_explicit (Small_defaultedIn_explicit_explicit &&rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_defaultedIn_explicit_explicit Small_defaultedIn_explicit_explicit_var; /* global var */
+
+template int cbv<Small_defaultedIn_explicit_explicit> (Small_defaultedIn_explicit_explicit arg);
+/*** C++ class Large_defaultedIn_explicit_explicit ***/
+class Large_defaultedIn_explicit_explicit {
+public:
+  Large_defaultedIn_explicit_explicit (void);
+  Large_defaultedIn_explicit_explicit (const Large_defaultedIn_explicit_explicit &rhs) = default;
+  ~Large_defaultedIn_explicit_explicit (void);
+  Large_defaultedIn_explicit_explicit (Large_defaultedIn_explicit_explicit &&rhs);
+
+
+  int data[150];
+};
+
+Large_defaultedIn_explicit_explicit::Large_defaultedIn_explicit_explicit (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedIn_explicit_explicit::~Large_defaultedIn_explicit_explicit (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_defaultedIn_explicit_explicit::Large_defaultedIn_explicit_explicit (Large_defaultedIn_explicit_explicit &&rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_defaultedIn_explicit_explicit Large_defaultedIn_explicit_explicit_var; /* global var */
+
+template int cbv<Large_defaultedIn_explicit_explicit> (Large_defaultedIn_explicit_explicit arg);
+/*** Class derived from Small_defaultedIn_explicit_explicit ***/
+class Derived_defaultedIn_explicit_explicit : public Small_defaultedIn_explicit_explicit {
+public:
+};
+
+Derived_defaultedIn_explicit_explicit Derived_defaultedIn_explicit_explicit_var; /* global var */
+
+template int cbv<Derived_defaultedIn_explicit_explicit> (Derived_defaultedIn_explicit_explicit arg);
+/*** Class that contains Small_defaultedIn_explicit_explicit ***/
+class Container_defaultedIn_explicit_explicit {
+public:
+  Small_defaultedIn_explicit_explicit item;
+};
+
+Container_defaultedIn_explicit_explicit Container_defaultedIn_explicit_explicit_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_explicit_explicit> (Container_defaultedIn_explicit_explicit arg);
+/*** C++ class Small_defaultedIn_explicit_defaultedIn ***/
+class Small_defaultedIn_explicit_defaultedIn {
+public:
+  Small_defaultedIn_explicit_defaultedIn (void);
+  Small_defaultedIn_explicit_defaultedIn (const Small_defaultedIn_explicit_defaultedIn &rhs) = default;
+  ~Small_defaultedIn_explicit_defaultedIn (void);
+  Small_defaultedIn_explicit_defaultedIn (Small_defaultedIn_explicit_defaultedIn &&rhs) = default;
+
+
+  int data[2];
+};
+
+Small_defaultedIn_explicit_defaultedIn::Small_defaultedIn_explicit_defaultedIn (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedIn_explicit_defaultedIn::~Small_defaultedIn_explicit_defaultedIn (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_defaultedIn_explicit_defaultedIn Small_defaultedIn_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Small_defaultedIn_explicit_defaultedIn> (Small_defaultedIn_explicit_defaultedIn arg);
+/*** C++ class Large_defaultedIn_explicit_defaultedIn ***/
+class Large_defaultedIn_explicit_defaultedIn {
+public:
+  Large_defaultedIn_explicit_defaultedIn (void);
+  Large_defaultedIn_explicit_defaultedIn (const Large_defaultedIn_explicit_defaultedIn &rhs) = default;
+  ~Large_defaultedIn_explicit_defaultedIn (void);
+  Large_defaultedIn_explicit_defaultedIn (Large_defaultedIn_explicit_defaultedIn &&rhs) = default;
+
+
+  int data[150];
+};
+
+Large_defaultedIn_explicit_defaultedIn::Large_defaultedIn_explicit_defaultedIn (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedIn_explicit_defaultedIn::~Large_defaultedIn_explicit_defaultedIn (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_defaultedIn_explicit_defaultedIn Large_defaultedIn_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Large_defaultedIn_explicit_defaultedIn> (Large_defaultedIn_explicit_defaultedIn arg);
+/*** Class derived from Small_defaultedIn_explicit_defaultedIn ***/
+class Derived_defaultedIn_explicit_defaultedIn : public Small_defaultedIn_explicit_defaultedIn {
+public:
+};
+
+Derived_defaultedIn_explicit_defaultedIn Derived_defaultedIn_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Derived_defaultedIn_explicit_defaultedIn> (Derived_defaultedIn_explicit_defaultedIn arg);
+/*** Class that contains Small_defaultedIn_explicit_defaultedIn ***/
+class Container_defaultedIn_explicit_defaultedIn {
+public:
+  Small_defaultedIn_explicit_defaultedIn item;
+};
+
+Container_defaultedIn_explicit_defaultedIn Container_defaultedIn_explicit_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_explicit_defaultedIn> (Container_defaultedIn_explicit_defaultedIn arg);
+/*** C++ class Small_defaultedIn_explicit_defaultedOut ***/
+class Small_defaultedIn_explicit_defaultedOut {
+public:
+  Small_defaultedIn_explicit_defaultedOut (void);
+  Small_defaultedIn_explicit_defaultedOut (const Small_defaultedIn_explicit_defaultedOut &rhs) = default;
+  ~Small_defaultedIn_explicit_defaultedOut (void);
+  Small_defaultedIn_explicit_defaultedOut (Small_defaultedIn_explicit_defaultedOut &&rhs);
+
+
+  int data[2];
+};
+
+Small_defaultedIn_explicit_defaultedOut::Small_defaultedIn_explicit_defaultedOut (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedIn_explicit_defaultedOut::~Small_defaultedIn_explicit_defaultedOut (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_defaultedIn_explicit_defaultedOut::Small_defaultedIn_explicit_defaultedOut (Small_defaultedIn_explicit_defaultedOut &&rhs) = default;
+
+
+Small_defaultedIn_explicit_defaultedOut Small_defaultedIn_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Small_defaultedIn_explicit_defaultedOut> (Small_defaultedIn_explicit_defaultedOut arg);
+/*** C++ class Large_defaultedIn_explicit_defaultedOut ***/
+class Large_defaultedIn_explicit_defaultedOut {
+public:
+  Large_defaultedIn_explicit_defaultedOut (void);
+  Large_defaultedIn_explicit_defaultedOut (const Large_defaultedIn_explicit_defaultedOut &rhs) = default;
+  ~Large_defaultedIn_explicit_defaultedOut (void);
+  Large_defaultedIn_explicit_defaultedOut (Large_defaultedIn_explicit_defaultedOut &&rhs);
+
+
+  int data[150];
+};
+
+Large_defaultedIn_explicit_defaultedOut::Large_defaultedIn_explicit_defaultedOut (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedIn_explicit_defaultedOut::~Large_defaultedIn_explicit_defaultedOut (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_defaultedIn_explicit_defaultedOut::Large_defaultedIn_explicit_defaultedOut (Large_defaultedIn_explicit_defaultedOut &&rhs) = default;
+
+
+Large_defaultedIn_explicit_defaultedOut Large_defaultedIn_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Large_defaultedIn_explicit_defaultedOut> (Large_defaultedIn_explicit_defaultedOut arg);
+/*** Class derived from Small_defaultedIn_explicit_defaultedOut ***/
+class Derived_defaultedIn_explicit_defaultedOut : public Small_defaultedIn_explicit_defaultedOut {
+public:
+};
+
+Derived_defaultedIn_explicit_defaultedOut Derived_defaultedIn_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Derived_defaultedIn_explicit_defaultedOut> (Derived_defaultedIn_explicit_defaultedOut arg);
+/*** Class that contains Small_defaultedIn_explicit_defaultedOut ***/
+class Container_defaultedIn_explicit_defaultedOut {
+public:
+  Small_defaultedIn_explicit_defaultedOut item;
+};
+
+Container_defaultedIn_explicit_defaultedOut Container_defaultedIn_explicit_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_explicit_defaultedOut> (Container_defaultedIn_explicit_defaultedOut arg);
+/*** C++ class Small_defaultedIn_explicit_deleted ***/
+class Small_defaultedIn_explicit_deleted {
+public:
+  Small_defaultedIn_explicit_deleted (void);
+  Small_defaultedIn_explicit_deleted (const Small_defaultedIn_explicit_deleted &rhs) = default;
+  ~Small_defaultedIn_explicit_deleted (void);
+  Small_defaultedIn_explicit_deleted (Small_defaultedIn_explicit_deleted &&rhs) = delete;
+
+
+  int data[2];
+};
+
+Small_defaultedIn_explicit_deleted::Small_defaultedIn_explicit_deleted (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedIn_explicit_deleted::~Small_defaultedIn_explicit_deleted (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_defaultedIn_explicit_deleted Small_defaultedIn_explicit_deleted_var; /* global var */
+
+template int cbv<Small_defaultedIn_explicit_deleted> (Small_defaultedIn_explicit_deleted arg);
+/*** C++ class Large_defaultedIn_explicit_deleted ***/
+class Large_defaultedIn_explicit_deleted {
+public:
+  Large_defaultedIn_explicit_deleted (void);
+  Large_defaultedIn_explicit_deleted (const Large_defaultedIn_explicit_deleted &rhs) = default;
+  ~Large_defaultedIn_explicit_deleted (void);
+  Large_defaultedIn_explicit_deleted (Large_defaultedIn_explicit_deleted &&rhs) = delete;
+
+
+  int data[150];
+};
+
+Large_defaultedIn_explicit_deleted::Large_defaultedIn_explicit_deleted (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedIn_explicit_deleted::~Large_defaultedIn_explicit_deleted (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_defaultedIn_explicit_deleted Large_defaultedIn_explicit_deleted_var; /* global var */
+
+template int cbv<Large_defaultedIn_explicit_deleted> (Large_defaultedIn_explicit_deleted arg);
+/*** Class derived from Small_defaultedIn_explicit_deleted ***/
+class Derived_defaultedIn_explicit_deleted : public Small_defaultedIn_explicit_deleted {
+public:
+};
+
+Derived_defaultedIn_explicit_deleted Derived_defaultedIn_explicit_deleted_var; /* global var */
+
+template int cbv<Derived_defaultedIn_explicit_deleted> (Derived_defaultedIn_explicit_deleted arg);
+/*** Class that contains Small_defaultedIn_explicit_deleted ***/
+class Container_defaultedIn_explicit_deleted {
+public:
+  Small_defaultedIn_explicit_deleted item;
+};
+
+Container_defaultedIn_explicit_deleted Container_defaultedIn_explicit_deleted_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_explicit_deleted> (Container_defaultedIn_explicit_deleted arg);
+/*** C++ class Small_defaultedIn_defaultedIn_absent ***/
+class Small_defaultedIn_defaultedIn_absent {
+public:
+  Small_defaultedIn_defaultedIn_absent (void);
+  Small_defaultedIn_defaultedIn_absent (const Small_defaultedIn_defaultedIn_absent &rhs) = default;
+  ~Small_defaultedIn_defaultedIn_absent (void) = default;
+
+
+  int data[2];
+};
+
+Small_defaultedIn_defaultedIn_absent::Small_defaultedIn_defaultedIn_absent (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+
+
+Small_defaultedIn_defaultedIn_absent Small_defaultedIn_defaultedIn_absent_var; /* global var */
+
+template int cbv<Small_defaultedIn_defaultedIn_absent> (Small_defaultedIn_defaultedIn_absent arg);
+/*** C++ class Large_defaultedIn_defaultedIn_absent ***/
+class Large_defaultedIn_defaultedIn_absent {
+public:
+  Large_defaultedIn_defaultedIn_absent (void);
+  Large_defaultedIn_defaultedIn_absent (const Large_defaultedIn_defaultedIn_absent &rhs) = default;
+  ~Large_defaultedIn_defaultedIn_absent (void) = default;
+
+
+  int data[150];
+};
+
+Large_defaultedIn_defaultedIn_absent::Large_defaultedIn_defaultedIn_absent (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+
+
+Large_defaultedIn_defaultedIn_absent Large_defaultedIn_defaultedIn_absent_var; /* global var */
+
+template int cbv<Large_defaultedIn_defaultedIn_absent> (Large_defaultedIn_defaultedIn_absent arg);
+/*** Class derived from Small_defaultedIn_defaultedIn_absent ***/
+class Derived_defaultedIn_defaultedIn_absent : public Small_defaultedIn_defaultedIn_absent {
+public:
+};
+
+Derived_defaultedIn_defaultedIn_absent Derived_defaultedIn_defaultedIn_absent_var; /* global var */
+
+template int cbv<Derived_defaultedIn_defaultedIn_absent> (Derived_defaultedIn_defaultedIn_absent arg);
+/*** Class that contains Small_defaultedIn_defaultedIn_absent ***/
+class Container_defaultedIn_defaultedIn_absent {
+public:
+  Small_defaultedIn_defaultedIn_absent item;
+};
+
+Container_defaultedIn_defaultedIn_absent Container_defaultedIn_defaultedIn_absent_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_defaultedIn_absent> (Container_defaultedIn_defaultedIn_absent arg);
+/*** C++ class Small_defaultedIn_defaultedIn_explicit ***/
+class Small_defaultedIn_defaultedIn_explicit {
+public:
+  Small_defaultedIn_defaultedIn_explicit (void);
+  Small_defaultedIn_defaultedIn_explicit (const Small_defaultedIn_defaultedIn_explicit &rhs) = default;
+  ~Small_defaultedIn_defaultedIn_explicit (void) = default;
+  Small_defaultedIn_defaultedIn_explicit (Small_defaultedIn_defaultedIn_explicit &&rhs);
+
+
+  int data[2];
+};
+
+Small_defaultedIn_defaultedIn_explicit::Small_defaultedIn_defaultedIn_explicit (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedIn_defaultedIn_explicit::Small_defaultedIn_defaultedIn_explicit (Small_defaultedIn_defaultedIn_explicit &&rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_defaultedIn_defaultedIn_explicit Small_defaultedIn_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Small_defaultedIn_defaultedIn_explicit> (Small_defaultedIn_defaultedIn_explicit arg);
+/*** C++ class Large_defaultedIn_defaultedIn_explicit ***/
+class Large_defaultedIn_defaultedIn_explicit {
+public:
+  Large_defaultedIn_defaultedIn_explicit (void);
+  Large_defaultedIn_defaultedIn_explicit (const Large_defaultedIn_defaultedIn_explicit &rhs) = default;
+  ~Large_defaultedIn_defaultedIn_explicit (void) = default;
+  Large_defaultedIn_defaultedIn_explicit (Large_defaultedIn_defaultedIn_explicit &&rhs);
+
+
+  int data[150];
+};
+
+Large_defaultedIn_defaultedIn_explicit::Large_defaultedIn_defaultedIn_explicit (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedIn_defaultedIn_explicit::Large_defaultedIn_defaultedIn_explicit (Large_defaultedIn_defaultedIn_explicit &&rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_defaultedIn_defaultedIn_explicit Large_defaultedIn_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Large_defaultedIn_defaultedIn_explicit> (Large_defaultedIn_defaultedIn_explicit arg);
+/*** Class derived from Small_defaultedIn_defaultedIn_explicit ***/
+class Derived_defaultedIn_defaultedIn_explicit : public Small_defaultedIn_defaultedIn_explicit {
+public:
+};
+
+Derived_defaultedIn_defaultedIn_explicit Derived_defaultedIn_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Derived_defaultedIn_defaultedIn_explicit> (Derived_defaultedIn_defaultedIn_explicit arg);
+/*** Class that contains Small_defaultedIn_defaultedIn_explicit ***/
+class Container_defaultedIn_defaultedIn_explicit {
+public:
+  Small_defaultedIn_defaultedIn_explicit item;
+};
+
+Container_defaultedIn_defaultedIn_explicit Container_defaultedIn_defaultedIn_explicit_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_defaultedIn_explicit> (Container_defaultedIn_defaultedIn_explicit arg);
+/*** C++ class Small_defaultedIn_defaultedIn_defaultedIn ***/
+class Small_defaultedIn_defaultedIn_defaultedIn {
+public:
+  Small_defaultedIn_defaultedIn_defaultedIn (void);
+  Small_defaultedIn_defaultedIn_defaultedIn (const Small_defaultedIn_defaultedIn_defaultedIn &rhs) = default;
+  ~Small_defaultedIn_defaultedIn_defaultedIn (void) = default;
+  Small_defaultedIn_defaultedIn_defaultedIn (Small_defaultedIn_defaultedIn_defaultedIn &&rhs) = default;
+
+
+  int data[2];
+};
+
+Small_defaultedIn_defaultedIn_defaultedIn::Small_defaultedIn_defaultedIn_defaultedIn (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+
+
+Small_defaultedIn_defaultedIn_defaultedIn Small_defaultedIn_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Small_defaultedIn_defaultedIn_defaultedIn> (Small_defaultedIn_defaultedIn_defaultedIn arg);
+/*** C++ class Large_defaultedIn_defaultedIn_defaultedIn ***/
+class Large_defaultedIn_defaultedIn_defaultedIn {
+public:
+  Large_defaultedIn_defaultedIn_defaultedIn (void);
+  Large_defaultedIn_defaultedIn_defaultedIn (const Large_defaultedIn_defaultedIn_defaultedIn &rhs) = default;
+  ~Large_defaultedIn_defaultedIn_defaultedIn (void) = default;
+  Large_defaultedIn_defaultedIn_defaultedIn (Large_defaultedIn_defaultedIn_defaultedIn &&rhs) = default;
+
+
+  int data[150];
+};
+
+Large_defaultedIn_defaultedIn_defaultedIn::Large_defaultedIn_defaultedIn_defaultedIn (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+
+
+Large_defaultedIn_defaultedIn_defaultedIn Large_defaultedIn_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Large_defaultedIn_defaultedIn_defaultedIn> (Large_defaultedIn_defaultedIn_defaultedIn arg);
+/*** Class derived from Small_defaultedIn_defaultedIn_defaultedIn ***/
+class Derived_defaultedIn_defaultedIn_defaultedIn : public Small_defaultedIn_defaultedIn_defaultedIn {
+public:
+};
+
+Derived_defaultedIn_defaultedIn_defaultedIn Derived_defaultedIn_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Derived_defaultedIn_defaultedIn_defaultedIn> (Derived_defaultedIn_defaultedIn_defaultedIn arg);
+/*** Class that contains Small_defaultedIn_defaultedIn_defaultedIn ***/
+class Container_defaultedIn_defaultedIn_defaultedIn {
+public:
+  Small_defaultedIn_defaultedIn_defaultedIn item;
+};
+
+Container_defaultedIn_defaultedIn_defaultedIn Container_defaultedIn_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_defaultedIn_defaultedIn> (Container_defaultedIn_defaultedIn_defaultedIn arg);
+/*** C++ class Small_defaultedIn_defaultedIn_defaultedOut ***/
+class Small_defaultedIn_defaultedIn_defaultedOut {
+public:
+  Small_defaultedIn_defaultedIn_defaultedOut (void);
+  Small_defaultedIn_defaultedIn_defaultedOut (const Small_defaultedIn_defaultedIn_defaultedOut &rhs) = default;
+  ~Small_defaultedIn_defaultedIn_defaultedOut (void) = default;
+  Small_defaultedIn_defaultedIn_defaultedOut (Small_defaultedIn_defaultedIn_defaultedOut &&rhs);
+
+
+  int data[2];
+};
+
+Small_defaultedIn_defaultedIn_defaultedOut::Small_defaultedIn_defaultedIn_defaultedOut (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedIn_defaultedIn_defaultedOut::Small_defaultedIn_defaultedIn_defaultedOut (Small_defaultedIn_defaultedIn_defaultedOut &&rhs) = default;
+
+
+Small_defaultedIn_defaultedIn_defaultedOut Small_defaultedIn_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Small_defaultedIn_defaultedIn_defaultedOut> (Small_defaultedIn_defaultedIn_defaultedOut arg);
+/*** C++ class Large_defaultedIn_defaultedIn_defaultedOut ***/
+class Large_defaultedIn_defaultedIn_defaultedOut {
+public:
+  Large_defaultedIn_defaultedIn_defaultedOut (void);
+  Large_defaultedIn_defaultedIn_defaultedOut (const Large_defaultedIn_defaultedIn_defaultedOut &rhs) = default;
+  ~Large_defaultedIn_defaultedIn_defaultedOut (void) = default;
+  Large_defaultedIn_defaultedIn_defaultedOut (Large_defaultedIn_defaultedIn_defaultedOut &&rhs);
+
+
+  int data[150];
+};
+
+Large_defaultedIn_defaultedIn_defaultedOut::Large_defaultedIn_defaultedIn_defaultedOut (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedIn_defaultedIn_defaultedOut::Large_defaultedIn_defaultedIn_defaultedOut (Large_defaultedIn_defaultedIn_defaultedOut &&rhs) = default;
+
+
+Large_defaultedIn_defaultedIn_defaultedOut Large_defaultedIn_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Large_defaultedIn_defaultedIn_defaultedOut> (Large_defaultedIn_defaultedIn_defaultedOut arg);
+/*** Class derived from Small_defaultedIn_defaultedIn_defaultedOut ***/
+class Derived_defaultedIn_defaultedIn_defaultedOut : public Small_defaultedIn_defaultedIn_defaultedOut {
+public:
+};
+
+Derived_defaultedIn_defaultedIn_defaultedOut Derived_defaultedIn_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Derived_defaultedIn_defaultedIn_defaultedOut> (Derived_defaultedIn_defaultedIn_defaultedOut arg);
+/*** Class that contains Small_defaultedIn_defaultedIn_defaultedOut ***/
+class Container_defaultedIn_defaultedIn_defaultedOut {
+public:
+  Small_defaultedIn_defaultedIn_defaultedOut item;
+};
+
+Container_defaultedIn_defaultedIn_defaultedOut Container_defaultedIn_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_defaultedIn_defaultedOut> (Container_defaultedIn_defaultedIn_defaultedOut arg);
+/*** C++ class Small_defaultedIn_defaultedIn_deleted ***/
+class Small_defaultedIn_defaultedIn_deleted {
+public:
+  Small_defaultedIn_defaultedIn_deleted (void);
+  Small_defaultedIn_defaultedIn_deleted (const Small_defaultedIn_defaultedIn_deleted &rhs) = default;
+  ~Small_defaultedIn_defaultedIn_deleted (void) = default;
+  Small_defaultedIn_defaultedIn_deleted (Small_defaultedIn_defaultedIn_deleted &&rhs) = delete;
+
+
+  int data[2];
+};
+
+Small_defaultedIn_defaultedIn_deleted::Small_defaultedIn_defaultedIn_deleted (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+
+
+Small_defaultedIn_defaultedIn_deleted Small_defaultedIn_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Small_defaultedIn_defaultedIn_deleted> (Small_defaultedIn_defaultedIn_deleted arg);
+/*** C++ class Large_defaultedIn_defaultedIn_deleted ***/
+class Large_defaultedIn_defaultedIn_deleted {
+public:
+  Large_defaultedIn_defaultedIn_deleted (void);
+  Large_defaultedIn_defaultedIn_deleted (const Large_defaultedIn_defaultedIn_deleted &rhs) = default;
+  ~Large_defaultedIn_defaultedIn_deleted (void) = default;
+  Large_defaultedIn_defaultedIn_deleted (Large_defaultedIn_defaultedIn_deleted &&rhs) = delete;
+
+
+  int data[150];
+};
+
+Large_defaultedIn_defaultedIn_deleted::Large_defaultedIn_defaultedIn_deleted (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+
+
+Large_defaultedIn_defaultedIn_deleted Large_defaultedIn_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Large_defaultedIn_defaultedIn_deleted> (Large_defaultedIn_defaultedIn_deleted arg);
+/*** Class derived from Small_defaultedIn_defaultedIn_deleted ***/
+class Derived_defaultedIn_defaultedIn_deleted : public Small_defaultedIn_defaultedIn_deleted {
+public:
+};
+
+Derived_defaultedIn_defaultedIn_deleted Derived_defaultedIn_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Derived_defaultedIn_defaultedIn_deleted> (Derived_defaultedIn_defaultedIn_deleted arg);
+/*** Class that contains Small_defaultedIn_defaultedIn_deleted ***/
+class Container_defaultedIn_defaultedIn_deleted {
+public:
+  Small_defaultedIn_defaultedIn_deleted item;
+};
+
+Container_defaultedIn_defaultedIn_deleted Container_defaultedIn_defaultedIn_deleted_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_defaultedIn_deleted> (Container_defaultedIn_defaultedIn_deleted arg);
+/*** C++ class Small_defaultedIn_defaultedOut_absent ***/
+class Small_defaultedIn_defaultedOut_absent {
+public:
+  Small_defaultedIn_defaultedOut_absent (void);
+  Small_defaultedIn_defaultedOut_absent (const Small_defaultedIn_defaultedOut_absent &rhs) = default;
+  ~Small_defaultedIn_defaultedOut_absent (void);
+
+
+  int data[2];
+};
+
+Small_defaultedIn_defaultedOut_absent::Small_defaultedIn_defaultedOut_absent (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedIn_defaultedOut_absent::~Small_defaultedIn_defaultedOut_absent (void) = default;
+
+
+Small_defaultedIn_defaultedOut_absent Small_defaultedIn_defaultedOut_absent_var; /* global var */
+
+template int cbv<Small_defaultedIn_defaultedOut_absent> (Small_defaultedIn_defaultedOut_absent arg);
+/*** C++ class Large_defaultedIn_defaultedOut_absent ***/
+class Large_defaultedIn_defaultedOut_absent {
+public:
+  Large_defaultedIn_defaultedOut_absent (void);
+  Large_defaultedIn_defaultedOut_absent (const Large_defaultedIn_defaultedOut_absent &rhs) = default;
+  ~Large_defaultedIn_defaultedOut_absent (void);
+
+
+  int data[150];
+};
+
+Large_defaultedIn_defaultedOut_absent::Large_defaultedIn_defaultedOut_absent (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedIn_defaultedOut_absent::~Large_defaultedIn_defaultedOut_absent (void) = default;
+
+
+Large_defaultedIn_defaultedOut_absent Large_defaultedIn_defaultedOut_absent_var; /* global var */
+
+template int cbv<Large_defaultedIn_defaultedOut_absent> (Large_defaultedIn_defaultedOut_absent arg);
+/*** Class derived from Small_defaultedIn_defaultedOut_absent ***/
+class Derived_defaultedIn_defaultedOut_absent : public Small_defaultedIn_defaultedOut_absent {
+public:
+};
+
+Derived_defaultedIn_defaultedOut_absent Derived_defaultedIn_defaultedOut_absent_var; /* global var */
+
+template int cbv<Derived_defaultedIn_defaultedOut_absent> (Derived_defaultedIn_defaultedOut_absent arg);
+/*** Class that contains Small_defaultedIn_defaultedOut_absent ***/
+class Container_defaultedIn_defaultedOut_absent {
+public:
+  Small_defaultedIn_defaultedOut_absent item;
+};
+
+Container_defaultedIn_defaultedOut_absent Container_defaultedIn_defaultedOut_absent_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_defaultedOut_absent> (Container_defaultedIn_defaultedOut_absent arg);
+/*** C++ class Small_defaultedIn_defaultedOut_explicit ***/
+class Small_defaultedIn_defaultedOut_explicit {
+public:
+  Small_defaultedIn_defaultedOut_explicit (void);
+  Small_defaultedIn_defaultedOut_explicit (const Small_defaultedIn_defaultedOut_explicit &rhs) = default;
+  ~Small_defaultedIn_defaultedOut_explicit (void);
+  Small_defaultedIn_defaultedOut_explicit (Small_defaultedIn_defaultedOut_explicit &&rhs);
+
+
+  int data[2];
+};
+
+Small_defaultedIn_defaultedOut_explicit::Small_defaultedIn_defaultedOut_explicit (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedIn_defaultedOut_explicit::~Small_defaultedIn_defaultedOut_explicit (void) = default;
+Small_defaultedIn_defaultedOut_explicit::Small_defaultedIn_defaultedOut_explicit (Small_defaultedIn_defaultedOut_explicit &&rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_defaultedIn_defaultedOut_explicit Small_defaultedIn_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Small_defaultedIn_defaultedOut_explicit> (Small_defaultedIn_defaultedOut_explicit arg);
+/*** C++ class Large_defaultedIn_defaultedOut_explicit ***/
+class Large_defaultedIn_defaultedOut_explicit {
+public:
+  Large_defaultedIn_defaultedOut_explicit (void);
+  Large_defaultedIn_defaultedOut_explicit (const Large_defaultedIn_defaultedOut_explicit &rhs) = default;
+  ~Large_defaultedIn_defaultedOut_explicit (void);
+  Large_defaultedIn_defaultedOut_explicit (Large_defaultedIn_defaultedOut_explicit &&rhs);
+
+
+  int data[150];
+};
+
+Large_defaultedIn_defaultedOut_explicit::Large_defaultedIn_defaultedOut_explicit (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedIn_defaultedOut_explicit::~Large_defaultedIn_defaultedOut_explicit (void) = default;
+Large_defaultedIn_defaultedOut_explicit::Large_defaultedIn_defaultedOut_explicit (Large_defaultedIn_defaultedOut_explicit &&rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_defaultedIn_defaultedOut_explicit Large_defaultedIn_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Large_defaultedIn_defaultedOut_explicit> (Large_defaultedIn_defaultedOut_explicit arg);
+/*** Class derived from Small_defaultedIn_defaultedOut_explicit ***/
+class Derived_defaultedIn_defaultedOut_explicit : public Small_defaultedIn_defaultedOut_explicit {
+public:
+};
+
+Derived_defaultedIn_defaultedOut_explicit Derived_defaultedIn_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Derived_defaultedIn_defaultedOut_explicit> (Derived_defaultedIn_defaultedOut_explicit arg);
+/*** Class that contains Small_defaultedIn_defaultedOut_explicit ***/
+class Container_defaultedIn_defaultedOut_explicit {
+public:
+  Small_defaultedIn_defaultedOut_explicit item;
+};
+
+Container_defaultedIn_defaultedOut_explicit Container_defaultedIn_defaultedOut_explicit_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_defaultedOut_explicit> (Container_defaultedIn_defaultedOut_explicit arg);
+/*** C++ class Small_defaultedIn_defaultedOut_defaultedIn ***/
+class Small_defaultedIn_defaultedOut_defaultedIn {
+public:
+  Small_defaultedIn_defaultedOut_defaultedIn (void);
+  Small_defaultedIn_defaultedOut_defaultedIn (const Small_defaultedIn_defaultedOut_defaultedIn &rhs) = default;
+  ~Small_defaultedIn_defaultedOut_defaultedIn (void);
+  Small_defaultedIn_defaultedOut_defaultedIn (Small_defaultedIn_defaultedOut_defaultedIn &&rhs) = default;
+
+
+  int data[2];
+};
+
+Small_defaultedIn_defaultedOut_defaultedIn::Small_defaultedIn_defaultedOut_defaultedIn (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedIn_defaultedOut_defaultedIn::~Small_defaultedIn_defaultedOut_defaultedIn (void) = default;
+
+
+Small_defaultedIn_defaultedOut_defaultedIn Small_defaultedIn_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Small_defaultedIn_defaultedOut_defaultedIn> (Small_defaultedIn_defaultedOut_defaultedIn arg);
+/*** C++ class Large_defaultedIn_defaultedOut_defaultedIn ***/
+class Large_defaultedIn_defaultedOut_defaultedIn {
+public:
+  Large_defaultedIn_defaultedOut_defaultedIn (void);
+  Large_defaultedIn_defaultedOut_defaultedIn (const Large_defaultedIn_defaultedOut_defaultedIn &rhs) = default;
+  ~Large_defaultedIn_defaultedOut_defaultedIn (void);
+  Large_defaultedIn_defaultedOut_defaultedIn (Large_defaultedIn_defaultedOut_defaultedIn &&rhs) = default;
+
+
+  int data[150];
+};
+
+Large_defaultedIn_defaultedOut_defaultedIn::Large_defaultedIn_defaultedOut_defaultedIn (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedIn_defaultedOut_defaultedIn::~Large_defaultedIn_defaultedOut_defaultedIn (void) = default;
+
+
+Large_defaultedIn_defaultedOut_defaultedIn Large_defaultedIn_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Large_defaultedIn_defaultedOut_defaultedIn> (Large_defaultedIn_defaultedOut_defaultedIn arg);
+/*** Class derived from Small_defaultedIn_defaultedOut_defaultedIn ***/
+class Derived_defaultedIn_defaultedOut_defaultedIn : public Small_defaultedIn_defaultedOut_defaultedIn {
+public:
+};
+
+Derived_defaultedIn_defaultedOut_defaultedIn Derived_defaultedIn_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Derived_defaultedIn_defaultedOut_defaultedIn> (Derived_defaultedIn_defaultedOut_defaultedIn arg);
+/*** Class that contains Small_defaultedIn_defaultedOut_defaultedIn ***/
+class Container_defaultedIn_defaultedOut_defaultedIn {
+public:
+  Small_defaultedIn_defaultedOut_defaultedIn item;
+};
+
+Container_defaultedIn_defaultedOut_defaultedIn Container_defaultedIn_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_defaultedOut_defaultedIn> (Container_defaultedIn_defaultedOut_defaultedIn arg);
+/*** C++ class Small_defaultedIn_defaultedOut_defaultedOut ***/
+class Small_defaultedIn_defaultedOut_defaultedOut {
+public:
+  Small_defaultedIn_defaultedOut_defaultedOut (void);
+  Small_defaultedIn_defaultedOut_defaultedOut (const Small_defaultedIn_defaultedOut_defaultedOut &rhs) = default;
+  ~Small_defaultedIn_defaultedOut_defaultedOut (void);
+  Small_defaultedIn_defaultedOut_defaultedOut (Small_defaultedIn_defaultedOut_defaultedOut &&rhs);
+
+
+  int data[2];
+};
+
+Small_defaultedIn_defaultedOut_defaultedOut::Small_defaultedIn_defaultedOut_defaultedOut (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedIn_defaultedOut_defaultedOut::~Small_defaultedIn_defaultedOut_defaultedOut (void) = default;
+Small_defaultedIn_defaultedOut_defaultedOut::Small_defaultedIn_defaultedOut_defaultedOut (Small_defaultedIn_defaultedOut_defaultedOut &&rhs) = default;
+
+
+Small_defaultedIn_defaultedOut_defaultedOut Small_defaultedIn_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Small_defaultedIn_defaultedOut_defaultedOut> (Small_defaultedIn_defaultedOut_defaultedOut arg);
+/*** C++ class Large_defaultedIn_defaultedOut_defaultedOut ***/
+class Large_defaultedIn_defaultedOut_defaultedOut {
+public:
+  Large_defaultedIn_defaultedOut_defaultedOut (void);
+  Large_defaultedIn_defaultedOut_defaultedOut (const Large_defaultedIn_defaultedOut_defaultedOut &rhs) = default;
+  ~Large_defaultedIn_defaultedOut_defaultedOut (void);
+  Large_defaultedIn_defaultedOut_defaultedOut (Large_defaultedIn_defaultedOut_defaultedOut &&rhs);
+
+
+  int data[150];
+};
+
+Large_defaultedIn_defaultedOut_defaultedOut::Large_defaultedIn_defaultedOut_defaultedOut (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedIn_defaultedOut_defaultedOut::~Large_defaultedIn_defaultedOut_defaultedOut (void) = default;
+Large_defaultedIn_defaultedOut_defaultedOut::Large_defaultedIn_defaultedOut_defaultedOut (Large_defaultedIn_defaultedOut_defaultedOut &&rhs) = default;
+
+
+Large_defaultedIn_defaultedOut_defaultedOut Large_defaultedIn_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Large_defaultedIn_defaultedOut_defaultedOut> (Large_defaultedIn_defaultedOut_defaultedOut arg);
+/*** Class derived from Small_defaultedIn_defaultedOut_defaultedOut ***/
+class Derived_defaultedIn_defaultedOut_defaultedOut : public Small_defaultedIn_defaultedOut_defaultedOut {
+public:
+};
+
+Derived_defaultedIn_defaultedOut_defaultedOut Derived_defaultedIn_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Derived_defaultedIn_defaultedOut_defaultedOut> (Derived_defaultedIn_defaultedOut_defaultedOut arg);
+/*** Class that contains Small_defaultedIn_defaultedOut_defaultedOut ***/
+class Container_defaultedIn_defaultedOut_defaultedOut {
+public:
+  Small_defaultedIn_defaultedOut_defaultedOut item;
+};
+
+Container_defaultedIn_defaultedOut_defaultedOut Container_defaultedIn_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_defaultedOut_defaultedOut> (Container_defaultedIn_defaultedOut_defaultedOut arg);
+/*** C++ class Small_defaultedIn_defaultedOut_deleted ***/
+class Small_defaultedIn_defaultedOut_deleted {
+public:
+  Small_defaultedIn_defaultedOut_deleted (void);
+  Small_defaultedIn_defaultedOut_deleted (const Small_defaultedIn_defaultedOut_deleted &rhs) = default;
+  ~Small_defaultedIn_defaultedOut_deleted (void);
+  Small_defaultedIn_defaultedOut_deleted (Small_defaultedIn_defaultedOut_deleted &&rhs) = delete;
+
+
+  int data[2];
+};
+
+Small_defaultedIn_defaultedOut_deleted::Small_defaultedIn_defaultedOut_deleted (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedIn_defaultedOut_deleted::~Small_defaultedIn_defaultedOut_deleted (void) = default;
+
+
+Small_defaultedIn_defaultedOut_deleted Small_defaultedIn_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Small_defaultedIn_defaultedOut_deleted> (Small_defaultedIn_defaultedOut_deleted arg);
+/*** C++ class Large_defaultedIn_defaultedOut_deleted ***/
+class Large_defaultedIn_defaultedOut_deleted {
+public:
+  Large_defaultedIn_defaultedOut_deleted (void);
+  Large_defaultedIn_defaultedOut_deleted (const Large_defaultedIn_defaultedOut_deleted &rhs) = default;
+  ~Large_defaultedIn_defaultedOut_deleted (void);
+  Large_defaultedIn_defaultedOut_deleted (Large_defaultedIn_defaultedOut_deleted &&rhs) = delete;
+
+
+  int data[150];
+};
+
+Large_defaultedIn_defaultedOut_deleted::Large_defaultedIn_defaultedOut_deleted (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedIn_defaultedOut_deleted::~Large_defaultedIn_defaultedOut_deleted (void) = default;
+
+
+Large_defaultedIn_defaultedOut_deleted Large_defaultedIn_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Large_defaultedIn_defaultedOut_deleted> (Large_defaultedIn_defaultedOut_deleted arg);
+/*** Class derived from Small_defaultedIn_defaultedOut_deleted ***/
+class Derived_defaultedIn_defaultedOut_deleted : public Small_defaultedIn_defaultedOut_deleted {
+public:
+};
+
+Derived_defaultedIn_defaultedOut_deleted Derived_defaultedIn_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Derived_defaultedIn_defaultedOut_deleted> (Derived_defaultedIn_defaultedOut_deleted arg);
+/*** Class that contains Small_defaultedIn_defaultedOut_deleted ***/
+class Container_defaultedIn_defaultedOut_deleted {
+public:
+  Small_defaultedIn_defaultedOut_deleted item;
+};
+
+Container_defaultedIn_defaultedOut_deleted Container_defaultedIn_defaultedOut_deleted_var; /* global var */
+
+template int cbv_container<Container_defaultedIn_defaultedOut_deleted> (Container_defaultedIn_defaultedOut_deleted arg);
+/*** C++ class Small_defaultedOut_absent_absent ***/
+class Small_defaultedOut_absent_absent {
+public:
+  Small_defaultedOut_absent_absent (void);
+  Small_defaultedOut_absent_absent (const Small_defaultedOut_absent_absent &rhs);
+
+
+  int data[2];
+};
+
+Small_defaultedOut_absent_absent::Small_defaultedOut_absent_absent (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedOut_absent_absent::Small_defaultedOut_absent_absent (const Small_defaultedOut_absent_absent &rhs) = default;
+
+
+Small_defaultedOut_absent_absent Small_defaultedOut_absent_absent_var; /* global var */
+
+template int cbv<Small_defaultedOut_absent_absent> (Small_defaultedOut_absent_absent arg);
+/*** C++ class Large_defaultedOut_absent_absent ***/
+class Large_defaultedOut_absent_absent {
+public:
+  Large_defaultedOut_absent_absent (void);
+  Large_defaultedOut_absent_absent (const Large_defaultedOut_absent_absent &rhs);
+
+
+  int data[150];
+};
+
+Large_defaultedOut_absent_absent::Large_defaultedOut_absent_absent (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedOut_absent_absent::Large_defaultedOut_absent_absent (const Large_defaultedOut_absent_absent &rhs) = default;
+
+
+Large_defaultedOut_absent_absent Large_defaultedOut_absent_absent_var; /* global var */
+
+template int cbv<Large_defaultedOut_absent_absent> (Large_defaultedOut_absent_absent arg);
+/*** Class derived from Small_defaultedOut_absent_absent ***/
+class Derived_defaultedOut_absent_absent : public Small_defaultedOut_absent_absent {
+public:
+};
+
+Derived_defaultedOut_absent_absent Derived_defaultedOut_absent_absent_var; /* global var */
+
+template int cbv<Derived_defaultedOut_absent_absent> (Derived_defaultedOut_absent_absent arg);
+/*** Class that contains Small_defaultedOut_absent_absent ***/
+class Container_defaultedOut_absent_absent {
+public:
+  Small_defaultedOut_absent_absent item;
+};
+
+Container_defaultedOut_absent_absent Container_defaultedOut_absent_absent_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_absent_absent> (Container_defaultedOut_absent_absent arg);
+/*** C++ class Small_defaultedOut_absent_explicit ***/
+class Small_defaultedOut_absent_explicit {
+public:
+  Small_defaultedOut_absent_explicit (void);
+  Small_defaultedOut_absent_explicit (const Small_defaultedOut_absent_explicit &rhs);
+  Small_defaultedOut_absent_explicit (Small_defaultedOut_absent_explicit &&rhs);
+
+
+  int data[2];
+};
+
+Small_defaultedOut_absent_explicit::Small_defaultedOut_absent_explicit (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedOut_absent_explicit::Small_defaultedOut_absent_explicit (const Small_defaultedOut_absent_explicit &rhs) = default;
+Small_defaultedOut_absent_explicit::Small_defaultedOut_absent_explicit (Small_defaultedOut_absent_explicit &&rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_defaultedOut_absent_explicit Small_defaultedOut_absent_explicit_var; /* global var */
+
+template int cbv<Small_defaultedOut_absent_explicit> (Small_defaultedOut_absent_explicit arg);
+/*** C++ class Large_defaultedOut_absent_explicit ***/
+class Large_defaultedOut_absent_explicit {
+public:
+  Large_defaultedOut_absent_explicit (void);
+  Large_defaultedOut_absent_explicit (const Large_defaultedOut_absent_explicit &rhs);
+  Large_defaultedOut_absent_explicit (Large_defaultedOut_absent_explicit &&rhs);
+
+
+  int data[150];
+};
+
+Large_defaultedOut_absent_explicit::Large_defaultedOut_absent_explicit (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedOut_absent_explicit::Large_defaultedOut_absent_explicit (const Large_defaultedOut_absent_explicit &rhs) = default;
+Large_defaultedOut_absent_explicit::Large_defaultedOut_absent_explicit (Large_defaultedOut_absent_explicit &&rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_defaultedOut_absent_explicit Large_defaultedOut_absent_explicit_var; /* global var */
+
+template int cbv<Large_defaultedOut_absent_explicit> (Large_defaultedOut_absent_explicit arg);
+/*** Class derived from Small_defaultedOut_absent_explicit ***/
+class Derived_defaultedOut_absent_explicit : public Small_defaultedOut_absent_explicit {
+public:
+};
+
+Derived_defaultedOut_absent_explicit Derived_defaultedOut_absent_explicit_var; /* global var */
+
+template int cbv<Derived_defaultedOut_absent_explicit> (Derived_defaultedOut_absent_explicit arg);
+/*** Class that contains Small_defaultedOut_absent_explicit ***/
+class Container_defaultedOut_absent_explicit {
+public:
+  Small_defaultedOut_absent_explicit item;
+};
+
+Container_defaultedOut_absent_explicit Container_defaultedOut_absent_explicit_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_absent_explicit> (Container_defaultedOut_absent_explicit arg);
+/*** C++ class Small_defaultedOut_absent_defaultedIn ***/
+class Small_defaultedOut_absent_defaultedIn {
+public:
+  Small_defaultedOut_absent_defaultedIn (void);
+  Small_defaultedOut_absent_defaultedIn (const Small_defaultedOut_absent_defaultedIn &rhs);
+  Small_defaultedOut_absent_defaultedIn (Small_defaultedOut_absent_defaultedIn &&rhs) = default;
+
+
+  int data[2];
+};
+
+Small_defaultedOut_absent_defaultedIn::Small_defaultedOut_absent_defaultedIn (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedOut_absent_defaultedIn::Small_defaultedOut_absent_defaultedIn (const Small_defaultedOut_absent_defaultedIn &rhs) = default;
+
+
+Small_defaultedOut_absent_defaultedIn Small_defaultedOut_absent_defaultedIn_var; /* global var */
+
+template int cbv<Small_defaultedOut_absent_defaultedIn> (Small_defaultedOut_absent_defaultedIn arg);
+/*** C++ class Large_defaultedOut_absent_defaultedIn ***/
+class Large_defaultedOut_absent_defaultedIn {
+public:
+  Large_defaultedOut_absent_defaultedIn (void);
+  Large_defaultedOut_absent_defaultedIn (const Large_defaultedOut_absent_defaultedIn &rhs);
+  Large_defaultedOut_absent_defaultedIn (Large_defaultedOut_absent_defaultedIn &&rhs) = default;
+
+
+  int data[150];
+};
+
+Large_defaultedOut_absent_defaultedIn::Large_defaultedOut_absent_defaultedIn (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedOut_absent_defaultedIn::Large_defaultedOut_absent_defaultedIn (const Large_defaultedOut_absent_defaultedIn &rhs) = default;
+
+
+Large_defaultedOut_absent_defaultedIn Large_defaultedOut_absent_defaultedIn_var; /* global var */
+
+template int cbv<Large_defaultedOut_absent_defaultedIn> (Large_defaultedOut_absent_defaultedIn arg);
+/*** Class derived from Small_defaultedOut_absent_defaultedIn ***/
+class Derived_defaultedOut_absent_defaultedIn : public Small_defaultedOut_absent_defaultedIn {
+public:
+};
+
+Derived_defaultedOut_absent_defaultedIn Derived_defaultedOut_absent_defaultedIn_var; /* global var */
+
+template int cbv<Derived_defaultedOut_absent_defaultedIn> (Derived_defaultedOut_absent_defaultedIn arg);
+/*** Class that contains Small_defaultedOut_absent_defaultedIn ***/
+class Container_defaultedOut_absent_defaultedIn {
+public:
+  Small_defaultedOut_absent_defaultedIn item;
+};
+
+Container_defaultedOut_absent_defaultedIn Container_defaultedOut_absent_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_absent_defaultedIn> (Container_defaultedOut_absent_defaultedIn arg);
+/*** C++ class Small_defaultedOut_absent_defaultedOut ***/
+class Small_defaultedOut_absent_defaultedOut {
+public:
+  Small_defaultedOut_absent_defaultedOut (void);
+  Small_defaultedOut_absent_defaultedOut (const Small_defaultedOut_absent_defaultedOut &rhs);
+  Small_defaultedOut_absent_defaultedOut (Small_defaultedOut_absent_defaultedOut &&rhs);
+
+
+  int data[2];
+};
+
+Small_defaultedOut_absent_defaultedOut::Small_defaultedOut_absent_defaultedOut (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedOut_absent_defaultedOut::Small_defaultedOut_absent_defaultedOut (const Small_defaultedOut_absent_defaultedOut &rhs) = default;
+Small_defaultedOut_absent_defaultedOut::Small_defaultedOut_absent_defaultedOut (Small_defaultedOut_absent_defaultedOut &&rhs) = default;
+
+
+Small_defaultedOut_absent_defaultedOut Small_defaultedOut_absent_defaultedOut_var; /* global var */
+
+template int cbv<Small_defaultedOut_absent_defaultedOut> (Small_defaultedOut_absent_defaultedOut arg);
+/*** C++ class Large_defaultedOut_absent_defaultedOut ***/
+class Large_defaultedOut_absent_defaultedOut {
+public:
+  Large_defaultedOut_absent_defaultedOut (void);
+  Large_defaultedOut_absent_defaultedOut (const Large_defaultedOut_absent_defaultedOut &rhs);
+  Large_defaultedOut_absent_defaultedOut (Large_defaultedOut_absent_defaultedOut &&rhs);
+
+
+  int data[150];
+};
+
+Large_defaultedOut_absent_defaultedOut::Large_defaultedOut_absent_defaultedOut (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedOut_absent_defaultedOut::Large_defaultedOut_absent_defaultedOut (const Large_defaultedOut_absent_defaultedOut &rhs) = default;
+Large_defaultedOut_absent_defaultedOut::Large_defaultedOut_absent_defaultedOut (Large_defaultedOut_absent_defaultedOut &&rhs) = default;
+
+
+Large_defaultedOut_absent_defaultedOut Large_defaultedOut_absent_defaultedOut_var; /* global var */
+
+template int cbv<Large_defaultedOut_absent_defaultedOut> (Large_defaultedOut_absent_defaultedOut arg);
+/*** Class derived from Small_defaultedOut_absent_defaultedOut ***/
+class Derived_defaultedOut_absent_defaultedOut : public Small_defaultedOut_absent_defaultedOut {
+public:
+};
+
+Derived_defaultedOut_absent_defaultedOut Derived_defaultedOut_absent_defaultedOut_var; /* global var */
+
+template int cbv<Derived_defaultedOut_absent_defaultedOut> (Derived_defaultedOut_absent_defaultedOut arg);
+/*** Class that contains Small_defaultedOut_absent_defaultedOut ***/
+class Container_defaultedOut_absent_defaultedOut {
+public:
+  Small_defaultedOut_absent_defaultedOut item;
+};
+
+Container_defaultedOut_absent_defaultedOut Container_defaultedOut_absent_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_absent_defaultedOut> (Container_defaultedOut_absent_defaultedOut arg);
+/*** C++ class Small_defaultedOut_absent_deleted ***/
+class Small_defaultedOut_absent_deleted {
+public:
+  Small_defaultedOut_absent_deleted (void);
+  Small_defaultedOut_absent_deleted (const Small_defaultedOut_absent_deleted &rhs);
+  Small_defaultedOut_absent_deleted (Small_defaultedOut_absent_deleted &&rhs) = delete;
+
+
+  int data[2];
+};
+
+Small_defaultedOut_absent_deleted::Small_defaultedOut_absent_deleted (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedOut_absent_deleted::Small_defaultedOut_absent_deleted (const Small_defaultedOut_absent_deleted &rhs) = default;
+
+
+Small_defaultedOut_absent_deleted Small_defaultedOut_absent_deleted_var; /* global var */
+
+template int cbv<Small_defaultedOut_absent_deleted> (Small_defaultedOut_absent_deleted arg);
+/*** C++ class Large_defaultedOut_absent_deleted ***/
+class Large_defaultedOut_absent_deleted {
+public:
+  Large_defaultedOut_absent_deleted (void);
+  Large_defaultedOut_absent_deleted (const Large_defaultedOut_absent_deleted &rhs);
+  Large_defaultedOut_absent_deleted (Large_defaultedOut_absent_deleted &&rhs) = delete;
+
+
+  int data[150];
+};
+
+Large_defaultedOut_absent_deleted::Large_defaultedOut_absent_deleted (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedOut_absent_deleted::Large_defaultedOut_absent_deleted (const Large_defaultedOut_absent_deleted &rhs) = default;
+
+
+Large_defaultedOut_absent_deleted Large_defaultedOut_absent_deleted_var; /* global var */
+
+template int cbv<Large_defaultedOut_absent_deleted> (Large_defaultedOut_absent_deleted arg);
+/*** Class derived from Small_defaultedOut_absent_deleted ***/
+class Derived_defaultedOut_absent_deleted : public Small_defaultedOut_absent_deleted {
+public:
+};
+
+Derived_defaultedOut_absent_deleted Derived_defaultedOut_absent_deleted_var; /* global var */
+
+template int cbv<Derived_defaultedOut_absent_deleted> (Derived_defaultedOut_absent_deleted arg);
+/*** Class that contains Small_defaultedOut_absent_deleted ***/
+class Container_defaultedOut_absent_deleted {
+public:
+  Small_defaultedOut_absent_deleted item;
+};
+
+Container_defaultedOut_absent_deleted Container_defaultedOut_absent_deleted_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_absent_deleted> (Container_defaultedOut_absent_deleted arg);
+/*** C++ class Small_defaultedOut_explicit_absent ***/
+class Small_defaultedOut_explicit_absent {
+public:
+  Small_defaultedOut_explicit_absent (void);
+  Small_defaultedOut_explicit_absent (const Small_defaultedOut_explicit_absent &rhs);
+  ~Small_defaultedOut_explicit_absent (void);
+
+
+  int data[2];
+};
+
+Small_defaultedOut_explicit_absent::Small_defaultedOut_explicit_absent (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedOut_explicit_absent::Small_defaultedOut_explicit_absent (const Small_defaultedOut_explicit_absent &rhs) = default;
+Small_defaultedOut_explicit_absent::~Small_defaultedOut_explicit_absent (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_defaultedOut_explicit_absent Small_defaultedOut_explicit_absent_var; /* global var */
+
+template int cbv<Small_defaultedOut_explicit_absent> (Small_defaultedOut_explicit_absent arg);
+/*** C++ class Large_defaultedOut_explicit_absent ***/
+class Large_defaultedOut_explicit_absent {
+public:
+  Large_defaultedOut_explicit_absent (void);
+  Large_defaultedOut_explicit_absent (const Large_defaultedOut_explicit_absent &rhs);
+  ~Large_defaultedOut_explicit_absent (void);
+
+
+  int data[150];
+};
+
+Large_defaultedOut_explicit_absent::Large_defaultedOut_explicit_absent (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedOut_explicit_absent::Large_defaultedOut_explicit_absent (const Large_defaultedOut_explicit_absent &rhs) = default;
+Large_defaultedOut_explicit_absent::~Large_defaultedOut_explicit_absent (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_defaultedOut_explicit_absent Large_defaultedOut_explicit_absent_var; /* global var */
+
+template int cbv<Large_defaultedOut_explicit_absent> (Large_defaultedOut_explicit_absent arg);
+/*** Class derived from Small_defaultedOut_explicit_absent ***/
+class Derived_defaultedOut_explicit_absent : public Small_defaultedOut_explicit_absent {
+public:
+};
+
+Derived_defaultedOut_explicit_absent Derived_defaultedOut_explicit_absent_var; /* global var */
+
+template int cbv<Derived_defaultedOut_explicit_absent> (Derived_defaultedOut_explicit_absent arg);
+/*** Class that contains Small_defaultedOut_explicit_absent ***/
+class Container_defaultedOut_explicit_absent {
+public:
+  Small_defaultedOut_explicit_absent item;
+};
+
+Container_defaultedOut_explicit_absent Container_defaultedOut_explicit_absent_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_explicit_absent> (Container_defaultedOut_explicit_absent arg);
+/*** C++ class Small_defaultedOut_explicit_explicit ***/
+class Small_defaultedOut_explicit_explicit {
+public:
+  Small_defaultedOut_explicit_explicit (void);
+  Small_defaultedOut_explicit_explicit (const Small_defaultedOut_explicit_explicit &rhs);
+  ~Small_defaultedOut_explicit_explicit (void);
+  Small_defaultedOut_explicit_explicit (Small_defaultedOut_explicit_explicit &&rhs);
+
+
+  int data[2];
+};
+
+Small_defaultedOut_explicit_explicit::Small_defaultedOut_explicit_explicit (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedOut_explicit_explicit::Small_defaultedOut_explicit_explicit (const Small_defaultedOut_explicit_explicit &rhs) = default;
+Small_defaultedOut_explicit_explicit::~Small_defaultedOut_explicit_explicit (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_defaultedOut_explicit_explicit::Small_defaultedOut_explicit_explicit (Small_defaultedOut_explicit_explicit &&rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_defaultedOut_explicit_explicit Small_defaultedOut_explicit_explicit_var; /* global var */
+
+template int cbv<Small_defaultedOut_explicit_explicit> (Small_defaultedOut_explicit_explicit arg);
+/*** C++ class Large_defaultedOut_explicit_explicit ***/
+class Large_defaultedOut_explicit_explicit {
+public:
+  Large_defaultedOut_explicit_explicit (void);
+  Large_defaultedOut_explicit_explicit (const Large_defaultedOut_explicit_explicit &rhs);
+  ~Large_defaultedOut_explicit_explicit (void);
+  Large_defaultedOut_explicit_explicit (Large_defaultedOut_explicit_explicit &&rhs);
+
+
+  int data[150];
+};
+
+Large_defaultedOut_explicit_explicit::Large_defaultedOut_explicit_explicit (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedOut_explicit_explicit::Large_defaultedOut_explicit_explicit (const Large_defaultedOut_explicit_explicit &rhs) = default;
+Large_defaultedOut_explicit_explicit::~Large_defaultedOut_explicit_explicit (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_defaultedOut_explicit_explicit::Large_defaultedOut_explicit_explicit (Large_defaultedOut_explicit_explicit &&rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_defaultedOut_explicit_explicit Large_defaultedOut_explicit_explicit_var; /* global var */
+
+template int cbv<Large_defaultedOut_explicit_explicit> (Large_defaultedOut_explicit_explicit arg);
+/*** Class derived from Small_defaultedOut_explicit_explicit ***/
+class Derived_defaultedOut_explicit_explicit : public Small_defaultedOut_explicit_explicit {
+public:
+};
+
+Derived_defaultedOut_explicit_explicit Derived_defaultedOut_explicit_explicit_var; /* global var */
+
+template int cbv<Derived_defaultedOut_explicit_explicit> (Derived_defaultedOut_explicit_explicit arg);
+/*** Class that contains Small_defaultedOut_explicit_explicit ***/
+class Container_defaultedOut_explicit_explicit {
+public:
+  Small_defaultedOut_explicit_explicit item;
+};
+
+Container_defaultedOut_explicit_explicit Container_defaultedOut_explicit_explicit_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_explicit_explicit> (Container_defaultedOut_explicit_explicit arg);
+/*** C++ class Small_defaultedOut_explicit_defaultedIn ***/
+class Small_defaultedOut_explicit_defaultedIn {
+public:
+  Small_defaultedOut_explicit_defaultedIn (void);
+  Small_defaultedOut_explicit_defaultedIn (const Small_defaultedOut_explicit_defaultedIn &rhs);
+  ~Small_defaultedOut_explicit_defaultedIn (void);
+  Small_defaultedOut_explicit_defaultedIn (Small_defaultedOut_explicit_defaultedIn &&rhs) = default;
+
+
+  int data[2];
+};
+
+Small_defaultedOut_explicit_defaultedIn::Small_defaultedOut_explicit_defaultedIn (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedOut_explicit_defaultedIn::Small_defaultedOut_explicit_defaultedIn (const Small_defaultedOut_explicit_defaultedIn &rhs) = default;
+Small_defaultedOut_explicit_defaultedIn::~Small_defaultedOut_explicit_defaultedIn (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_defaultedOut_explicit_defaultedIn Small_defaultedOut_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Small_defaultedOut_explicit_defaultedIn> (Small_defaultedOut_explicit_defaultedIn arg);
+/*** C++ class Large_defaultedOut_explicit_defaultedIn ***/
+class Large_defaultedOut_explicit_defaultedIn {
+public:
+  Large_defaultedOut_explicit_defaultedIn (void);
+  Large_defaultedOut_explicit_defaultedIn (const Large_defaultedOut_explicit_defaultedIn &rhs);
+  ~Large_defaultedOut_explicit_defaultedIn (void);
+  Large_defaultedOut_explicit_defaultedIn (Large_defaultedOut_explicit_defaultedIn &&rhs) = default;
+
+
+  int data[150];
+};
+
+Large_defaultedOut_explicit_defaultedIn::Large_defaultedOut_explicit_defaultedIn (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedOut_explicit_defaultedIn::Large_defaultedOut_explicit_defaultedIn (const Large_defaultedOut_explicit_defaultedIn &rhs) = default;
+Large_defaultedOut_explicit_defaultedIn::~Large_defaultedOut_explicit_defaultedIn (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_defaultedOut_explicit_defaultedIn Large_defaultedOut_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Large_defaultedOut_explicit_defaultedIn> (Large_defaultedOut_explicit_defaultedIn arg);
+/*** Class derived from Small_defaultedOut_explicit_defaultedIn ***/
+class Derived_defaultedOut_explicit_defaultedIn : public Small_defaultedOut_explicit_defaultedIn {
+public:
+};
+
+Derived_defaultedOut_explicit_defaultedIn Derived_defaultedOut_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Derived_defaultedOut_explicit_defaultedIn> (Derived_defaultedOut_explicit_defaultedIn arg);
+/*** Class that contains Small_defaultedOut_explicit_defaultedIn ***/
+class Container_defaultedOut_explicit_defaultedIn {
+public:
+  Small_defaultedOut_explicit_defaultedIn item;
+};
+
+Container_defaultedOut_explicit_defaultedIn Container_defaultedOut_explicit_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_explicit_defaultedIn> (Container_defaultedOut_explicit_defaultedIn arg);
+/*** C++ class Small_defaultedOut_explicit_defaultedOut ***/
+class Small_defaultedOut_explicit_defaultedOut {
+public:
+  Small_defaultedOut_explicit_defaultedOut (void);
+  Small_defaultedOut_explicit_defaultedOut (const Small_defaultedOut_explicit_defaultedOut &rhs);
+  ~Small_defaultedOut_explicit_defaultedOut (void);
+  Small_defaultedOut_explicit_defaultedOut (Small_defaultedOut_explicit_defaultedOut &&rhs);
+
+
+  int data[2];
+};
+
+Small_defaultedOut_explicit_defaultedOut::Small_defaultedOut_explicit_defaultedOut (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedOut_explicit_defaultedOut::Small_defaultedOut_explicit_defaultedOut (const Small_defaultedOut_explicit_defaultedOut &rhs) = default;
+Small_defaultedOut_explicit_defaultedOut::~Small_defaultedOut_explicit_defaultedOut (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_defaultedOut_explicit_defaultedOut::Small_defaultedOut_explicit_defaultedOut (Small_defaultedOut_explicit_defaultedOut &&rhs) = default;
+
+
+Small_defaultedOut_explicit_defaultedOut Small_defaultedOut_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Small_defaultedOut_explicit_defaultedOut> (Small_defaultedOut_explicit_defaultedOut arg);
+/*** C++ class Large_defaultedOut_explicit_defaultedOut ***/
+class Large_defaultedOut_explicit_defaultedOut {
+public:
+  Large_defaultedOut_explicit_defaultedOut (void);
+  Large_defaultedOut_explicit_defaultedOut (const Large_defaultedOut_explicit_defaultedOut &rhs);
+  ~Large_defaultedOut_explicit_defaultedOut (void);
+  Large_defaultedOut_explicit_defaultedOut (Large_defaultedOut_explicit_defaultedOut &&rhs);
+
+
+  int data[150];
+};
+
+Large_defaultedOut_explicit_defaultedOut::Large_defaultedOut_explicit_defaultedOut (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedOut_explicit_defaultedOut::Large_defaultedOut_explicit_defaultedOut (const Large_defaultedOut_explicit_defaultedOut &rhs) = default;
+Large_defaultedOut_explicit_defaultedOut::~Large_defaultedOut_explicit_defaultedOut (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_defaultedOut_explicit_defaultedOut::Large_defaultedOut_explicit_defaultedOut (Large_defaultedOut_explicit_defaultedOut &&rhs) = default;
+
+
+Large_defaultedOut_explicit_defaultedOut Large_defaultedOut_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Large_defaultedOut_explicit_defaultedOut> (Large_defaultedOut_explicit_defaultedOut arg);
+/*** Class derived from Small_defaultedOut_explicit_defaultedOut ***/
+class Derived_defaultedOut_explicit_defaultedOut : public Small_defaultedOut_explicit_defaultedOut {
+public:
+};
+
+Derived_defaultedOut_explicit_defaultedOut Derived_defaultedOut_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Derived_defaultedOut_explicit_defaultedOut> (Derived_defaultedOut_explicit_defaultedOut arg);
+/*** Class that contains Small_defaultedOut_explicit_defaultedOut ***/
+class Container_defaultedOut_explicit_defaultedOut {
+public:
+  Small_defaultedOut_explicit_defaultedOut item;
+};
+
+Container_defaultedOut_explicit_defaultedOut Container_defaultedOut_explicit_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_explicit_defaultedOut> (Container_defaultedOut_explicit_defaultedOut arg);
+/*** C++ class Small_defaultedOut_explicit_deleted ***/
+class Small_defaultedOut_explicit_deleted {
+public:
+  Small_defaultedOut_explicit_deleted (void);
+  Small_defaultedOut_explicit_deleted (const Small_defaultedOut_explicit_deleted &rhs);
+  ~Small_defaultedOut_explicit_deleted (void);
+  Small_defaultedOut_explicit_deleted (Small_defaultedOut_explicit_deleted &&rhs) = delete;
+
+
+  int data[2];
+};
+
+Small_defaultedOut_explicit_deleted::Small_defaultedOut_explicit_deleted (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedOut_explicit_deleted::Small_defaultedOut_explicit_deleted (const Small_defaultedOut_explicit_deleted &rhs) = default;
+Small_defaultedOut_explicit_deleted::~Small_defaultedOut_explicit_deleted (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_defaultedOut_explicit_deleted Small_defaultedOut_explicit_deleted_var; /* global var */
+
+template int cbv<Small_defaultedOut_explicit_deleted> (Small_defaultedOut_explicit_deleted arg);
+/*** C++ class Large_defaultedOut_explicit_deleted ***/
+class Large_defaultedOut_explicit_deleted {
+public:
+  Large_defaultedOut_explicit_deleted (void);
+  Large_defaultedOut_explicit_deleted (const Large_defaultedOut_explicit_deleted &rhs);
+  ~Large_defaultedOut_explicit_deleted (void);
+  Large_defaultedOut_explicit_deleted (Large_defaultedOut_explicit_deleted &&rhs) = delete;
+
+
+  int data[150];
+};
+
+Large_defaultedOut_explicit_deleted::Large_defaultedOut_explicit_deleted (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedOut_explicit_deleted::Large_defaultedOut_explicit_deleted (const Large_defaultedOut_explicit_deleted &rhs) = default;
+Large_defaultedOut_explicit_deleted::~Large_defaultedOut_explicit_deleted (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_defaultedOut_explicit_deleted Large_defaultedOut_explicit_deleted_var; /* global var */
+
+template int cbv<Large_defaultedOut_explicit_deleted> (Large_defaultedOut_explicit_deleted arg);
+/*** Class derived from Small_defaultedOut_explicit_deleted ***/
+class Derived_defaultedOut_explicit_deleted : public Small_defaultedOut_explicit_deleted {
+public:
+};
+
+Derived_defaultedOut_explicit_deleted Derived_defaultedOut_explicit_deleted_var; /* global var */
+
+template int cbv<Derived_defaultedOut_explicit_deleted> (Derived_defaultedOut_explicit_deleted arg);
+/*** Class that contains Small_defaultedOut_explicit_deleted ***/
+class Container_defaultedOut_explicit_deleted {
+public:
+  Small_defaultedOut_explicit_deleted item;
+};
+
+Container_defaultedOut_explicit_deleted Container_defaultedOut_explicit_deleted_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_explicit_deleted> (Container_defaultedOut_explicit_deleted arg);
+/*** C++ class Small_defaultedOut_defaultedIn_absent ***/
+class Small_defaultedOut_defaultedIn_absent {
+public:
+  Small_defaultedOut_defaultedIn_absent (void);
+  Small_defaultedOut_defaultedIn_absent (const Small_defaultedOut_defaultedIn_absent &rhs);
+  ~Small_defaultedOut_defaultedIn_absent (void) = default;
+
+
+  int data[2];
+};
+
+Small_defaultedOut_defaultedIn_absent::Small_defaultedOut_defaultedIn_absent (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedOut_defaultedIn_absent::Small_defaultedOut_defaultedIn_absent (const Small_defaultedOut_defaultedIn_absent &rhs) = default;
+
+
+Small_defaultedOut_defaultedIn_absent Small_defaultedOut_defaultedIn_absent_var; /* global var */
+
+template int cbv<Small_defaultedOut_defaultedIn_absent> (Small_defaultedOut_defaultedIn_absent arg);
+/*** C++ class Large_defaultedOut_defaultedIn_absent ***/
+class Large_defaultedOut_defaultedIn_absent {
+public:
+  Large_defaultedOut_defaultedIn_absent (void);
+  Large_defaultedOut_defaultedIn_absent (const Large_defaultedOut_defaultedIn_absent &rhs);
+  ~Large_defaultedOut_defaultedIn_absent (void) = default;
+
+
+  int data[150];
+};
+
+Large_defaultedOut_defaultedIn_absent::Large_defaultedOut_defaultedIn_absent (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedOut_defaultedIn_absent::Large_defaultedOut_defaultedIn_absent (const Large_defaultedOut_defaultedIn_absent &rhs) = default;
+
+
+Large_defaultedOut_defaultedIn_absent Large_defaultedOut_defaultedIn_absent_var; /* global var */
+
+template int cbv<Large_defaultedOut_defaultedIn_absent> (Large_defaultedOut_defaultedIn_absent arg);
+/*** Class derived from Small_defaultedOut_defaultedIn_absent ***/
+class Derived_defaultedOut_defaultedIn_absent : public Small_defaultedOut_defaultedIn_absent {
+public:
+};
+
+Derived_defaultedOut_defaultedIn_absent Derived_defaultedOut_defaultedIn_absent_var; /* global var */
+
+template int cbv<Derived_defaultedOut_defaultedIn_absent> (Derived_defaultedOut_defaultedIn_absent arg);
+/*** Class that contains Small_defaultedOut_defaultedIn_absent ***/
+class Container_defaultedOut_defaultedIn_absent {
+public:
+  Small_defaultedOut_defaultedIn_absent item;
+};
+
+Container_defaultedOut_defaultedIn_absent Container_defaultedOut_defaultedIn_absent_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_defaultedIn_absent> (Container_defaultedOut_defaultedIn_absent arg);
+/*** C++ class Small_defaultedOut_defaultedIn_explicit ***/
+class Small_defaultedOut_defaultedIn_explicit {
+public:
+  Small_defaultedOut_defaultedIn_explicit (void);
+  Small_defaultedOut_defaultedIn_explicit (const Small_defaultedOut_defaultedIn_explicit &rhs);
+  ~Small_defaultedOut_defaultedIn_explicit (void) = default;
+  Small_defaultedOut_defaultedIn_explicit (Small_defaultedOut_defaultedIn_explicit &&rhs);
+
+
+  int data[2];
+};
+
+Small_defaultedOut_defaultedIn_explicit::Small_defaultedOut_defaultedIn_explicit (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedOut_defaultedIn_explicit::Small_defaultedOut_defaultedIn_explicit (const Small_defaultedOut_defaultedIn_explicit &rhs) = default;
+Small_defaultedOut_defaultedIn_explicit::Small_defaultedOut_defaultedIn_explicit (Small_defaultedOut_defaultedIn_explicit &&rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_defaultedOut_defaultedIn_explicit Small_defaultedOut_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Small_defaultedOut_defaultedIn_explicit> (Small_defaultedOut_defaultedIn_explicit arg);
+/*** C++ class Large_defaultedOut_defaultedIn_explicit ***/
+class Large_defaultedOut_defaultedIn_explicit {
+public:
+  Large_defaultedOut_defaultedIn_explicit (void);
+  Large_defaultedOut_defaultedIn_explicit (const Large_defaultedOut_defaultedIn_explicit &rhs);
+  ~Large_defaultedOut_defaultedIn_explicit (void) = default;
+  Large_defaultedOut_defaultedIn_explicit (Large_defaultedOut_defaultedIn_explicit &&rhs);
+
+
+  int data[150];
+};
+
+Large_defaultedOut_defaultedIn_explicit::Large_defaultedOut_defaultedIn_explicit (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedOut_defaultedIn_explicit::Large_defaultedOut_defaultedIn_explicit (const Large_defaultedOut_defaultedIn_explicit &rhs) = default;
+Large_defaultedOut_defaultedIn_explicit::Large_defaultedOut_defaultedIn_explicit (Large_defaultedOut_defaultedIn_explicit &&rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_defaultedOut_defaultedIn_explicit Large_defaultedOut_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Large_defaultedOut_defaultedIn_explicit> (Large_defaultedOut_defaultedIn_explicit arg);
+/*** Class derived from Small_defaultedOut_defaultedIn_explicit ***/
+class Derived_defaultedOut_defaultedIn_explicit : public Small_defaultedOut_defaultedIn_explicit {
+public:
+};
+
+Derived_defaultedOut_defaultedIn_explicit Derived_defaultedOut_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Derived_defaultedOut_defaultedIn_explicit> (Derived_defaultedOut_defaultedIn_explicit arg);
+/*** Class that contains Small_defaultedOut_defaultedIn_explicit ***/
+class Container_defaultedOut_defaultedIn_explicit {
+public:
+  Small_defaultedOut_defaultedIn_explicit item;
+};
+
+Container_defaultedOut_defaultedIn_explicit Container_defaultedOut_defaultedIn_explicit_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_defaultedIn_explicit> (Container_defaultedOut_defaultedIn_explicit arg);
+/*** C++ class Small_defaultedOut_defaultedIn_defaultedIn ***/
+class Small_defaultedOut_defaultedIn_defaultedIn {
+public:
+  Small_defaultedOut_defaultedIn_defaultedIn (void);
+  Small_defaultedOut_defaultedIn_defaultedIn (const Small_defaultedOut_defaultedIn_defaultedIn &rhs);
+  ~Small_defaultedOut_defaultedIn_defaultedIn (void) = default;
+  Small_defaultedOut_defaultedIn_defaultedIn (Small_defaultedOut_defaultedIn_defaultedIn &&rhs) = default;
+
+
+  int data[2];
+};
+
+Small_defaultedOut_defaultedIn_defaultedIn::Small_defaultedOut_defaultedIn_defaultedIn (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedOut_defaultedIn_defaultedIn::Small_defaultedOut_defaultedIn_defaultedIn (const Small_defaultedOut_defaultedIn_defaultedIn &rhs) = default;
+
+
+Small_defaultedOut_defaultedIn_defaultedIn Small_defaultedOut_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Small_defaultedOut_defaultedIn_defaultedIn> (Small_defaultedOut_defaultedIn_defaultedIn arg);
+/*** C++ class Large_defaultedOut_defaultedIn_defaultedIn ***/
+class Large_defaultedOut_defaultedIn_defaultedIn {
+public:
+  Large_defaultedOut_defaultedIn_defaultedIn (void);
+  Large_defaultedOut_defaultedIn_defaultedIn (const Large_defaultedOut_defaultedIn_defaultedIn &rhs);
+  ~Large_defaultedOut_defaultedIn_defaultedIn (void) = default;
+  Large_defaultedOut_defaultedIn_defaultedIn (Large_defaultedOut_defaultedIn_defaultedIn &&rhs) = default;
+
+
+  int data[150];
+};
+
+Large_defaultedOut_defaultedIn_defaultedIn::Large_defaultedOut_defaultedIn_defaultedIn (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedOut_defaultedIn_defaultedIn::Large_defaultedOut_defaultedIn_defaultedIn (const Large_defaultedOut_defaultedIn_defaultedIn &rhs) = default;
+
+
+Large_defaultedOut_defaultedIn_defaultedIn Large_defaultedOut_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Large_defaultedOut_defaultedIn_defaultedIn> (Large_defaultedOut_defaultedIn_defaultedIn arg);
+/*** Class derived from Small_defaultedOut_defaultedIn_defaultedIn ***/
+class Derived_defaultedOut_defaultedIn_defaultedIn : public Small_defaultedOut_defaultedIn_defaultedIn {
+public:
+};
+
+Derived_defaultedOut_defaultedIn_defaultedIn Derived_defaultedOut_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Derived_defaultedOut_defaultedIn_defaultedIn> (Derived_defaultedOut_defaultedIn_defaultedIn arg);
+/*** Class that contains Small_defaultedOut_defaultedIn_defaultedIn ***/
+class Container_defaultedOut_defaultedIn_defaultedIn {
+public:
+  Small_defaultedOut_defaultedIn_defaultedIn item;
+};
+
+Container_defaultedOut_defaultedIn_defaultedIn Container_defaultedOut_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_defaultedIn_defaultedIn> (Container_defaultedOut_defaultedIn_defaultedIn arg);
+/*** C++ class Small_defaultedOut_defaultedIn_defaultedOut ***/
+class Small_defaultedOut_defaultedIn_defaultedOut {
+public:
+  Small_defaultedOut_defaultedIn_defaultedOut (void);
+  Small_defaultedOut_defaultedIn_defaultedOut (const Small_defaultedOut_defaultedIn_defaultedOut &rhs);
+  ~Small_defaultedOut_defaultedIn_defaultedOut (void) = default;
+  Small_defaultedOut_defaultedIn_defaultedOut (Small_defaultedOut_defaultedIn_defaultedOut &&rhs);
+
+
+  int data[2];
+};
+
+Small_defaultedOut_defaultedIn_defaultedOut::Small_defaultedOut_defaultedIn_defaultedOut (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedOut_defaultedIn_defaultedOut::Small_defaultedOut_defaultedIn_defaultedOut (const Small_defaultedOut_defaultedIn_defaultedOut &rhs) = default;
+Small_defaultedOut_defaultedIn_defaultedOut::Small_defaultedOut_defaultedIn_defaultedOut (Small_defaultedOut_defaultedIn_defaultedOut &&rhs) = default;
+
+
+Small_defaultedOut_defaultedIn_defaultedOut Small_defaultedOut_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Small_defaultedOut_defaultedIn_defaultedOut> (Small_defaultedOut_defaultedIn_defaultedOut arg);
+/*** C++ class Large_defaultedOut_defaultedIn_defaultedOut ***/
+class Large_defaultedOut_defaultedIn_defaultedOut {
+public:
+  Large_defaultedOut_defaultedIn_defaultedOut (void);
+  Large_defaultedOut_defaultedIn_defaultedOut (const Large_defaultedOut_defaultedIn_defaultedOut &rhs);
+  ~Large_defaultedOut_defaultedIn_defaultedOut (void) = default;
+  Large_defaultedOut_defaultedIn_defaultedOut (Large_defaultedOut_defaultedIn_defaultedOut &&rhs);
+
+
+  int data[150];
+};
+
+Large_defaultedOut_defaultedIn_defaultedOut::Large_defaultedOut_defaultedIn_defaultedOut (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedOut_defaultedIn_defaultedOut::Large_defaultedOut_defaultedIn_defaultedOut (const Large_defaultedOut_defaultedIn_defaultedOut &rhs) = default;
+Large_defaultedOut_defaultedIn_defaultedOut::Large_defaultedOut_defaultedIn_defaultedOut (Large_defaultedOut_defaultedIn_defaultedOut &&rhs) = default;
+
+
+Large_defaultedOut_defaultedIn_defaultedOut Large_defaultedOut_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Large_defaultedOut_defaultedIn_defaultedOut> (Large_defaultedOut_defaultedIn_defaultedOut arg);
+/*** Class derived from Small_defaultedOut_defaultedIn_defaultedOut ***/
+class Derived_defaultedOut_defaultedIn_defaultedOut : public Small_defaultedOut_defaultedIn_defaultedOut {
+public:
+};
+
+Derived_defaultedOut_defaultedIn_defaultedOut Derived_defaultedOut_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Derived_defaultedOut_defaultedIn_defaultedOut> (Derived_defaultedOut_defaultedIn_defaultedOut arg);
+/*** Class that contains Small_defaultedOut_defaultedIn_defaultedOut ***/
+class Container_defaultedOut_defaultedIn_defaultedOut {
+public:
+  Small_defaultedOut_defaultedIn_defaultedOut item;
+};
+
+Container_defaultedOut_defaultedIn_defaultedOut Container_defaultedOut_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_defaultedIn_defaultedOut> (Container_defaultedOut_defaultedIn_defaultedOut arg);
+/*** C++ class Small_defaultedOut_defaultedIn_deleted ***/
+class Small_defaultedOut_defaultedIn_deleted {
+public:
+  Small_defaultedOut_defaultedIn_deleted (void);
+  Small_defaultedOut_defaultedIn_deleted (const Small_defaultedOut_defaultedIn_deleted &rhs);
+  ~Small_defaultedOut_defaultedIn_deleted (void) = default;
+  Small_defaultedOut_defaultedIn_deleted (Small_defaultedOut_defaultedIn_deleted &&rhs) = delete;
+
+
+  int data[2];
+};
+
+Small_defaultedOut_defaultedIn_deleted::Small_defaultedOut_defaultedIn_deleted (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedOut_defaultedIn_deleted::Small_defaultedOut_defaultedIn_deleted (const Small_defaultedOut_defaultedIn_deleted &rhs) = default;
+
+
+Small_defaultedOut_defaultedIn_deleted Small_defaultedOut_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Small_defaultedOut_defaultedIn_deleted> (Small_defaultedOut_defaultedIn_deleted arg);
+/*** C++ class Large_defaultedOut_defaultedIn_deleted ***/
+class Large_defaultedOut_defaultedIn_deleted {
+public:
+  Large_defaultedOut_defaultedIn_deleted (void);
+  Large_defaultedOut_defaultedIn_deleted (const Large_defaultedOut_defaultedIn_deleted &rhs);
+  ~Large_defaultedOut_defaultedIn_deleted (void) = default;
+  Large_defaultedOut_defaultedIn_deleted (Large_defaultedOut_defaultedIn_deleted &&rhs) = delete;
+
+
+  int data[150];
+};
+
+Large_defaultedOut_defaultedIn_deleted::Large_defaultedOut_defaultedIn_deleted (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedOut_defaultedIn_deleted::Large_defaultedOut_defaultedIn_deleted (const Large_defaultedOut_defaultedIn_deleted &rhs) = default;
+
+
+Large_defaultedOut_defaultedIn_deleted Large_defaultedOut_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Large_defaultedOut_defaultedIn_deleted> (Large_defaultedOut_defaultedIn_deleted arg);
+/*** Class derived from Small_defaultedOut_defaultedIn_deleted ***/
+class Derived_defaultedOut_defaultedIn_deleted : public Small_defaultedOut_defaultedIn_deleted {
+public:
+};
+
+Derived_defaultedOut_defaultedIn_deleted Derived_defaultedOut_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Derived_defaultedOut_defaultedIn_deleted> (Derived_defaultedOut_defaultedIn_deleted arg);
+/*** Class that contains Small_defaultedOut_defaultedIn_deleted ***/
+class Container_defaultedOut_defaultedIn_deleted {
+public:
+  Small_defaultedOut_defaultedIn_deleted item;
+};
+
+Container_defaultedOut_defaultedIn_deleted Container_defaultedOut_defaultedIn_deleted_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_defaultedIn_deleted> (Container_defaultedOut_defaultedIn_deleted arg);
+/*** C++ class Small_defaultedOut_defaultedOut_absent ***/
+class Small_defaultedOut_defaultedOut_absent {
+public:
+  Small_defaultedOut_defaultedOut_absent (void);
+  Small_defaultedOut_defaultedOut_absent (const Small_defaultedOut_defaultedOut_absent &rhs);
+  ~Small_defaultedOut_defaultedOut_absent (void);
+
+
+  int data[2];
+};
+
+Small_defaultedOut_defaultedOut_absent::Small_defaultedOut_defaultedOut_absent (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedOut_defaultedOut_absent::Small_defaultedOut_defaultedOut_absent (const Small_defaultedOut_defaultedOut_absent &rhs) = default;
+Small_defaultedOut_defaultedOut_absent::~Small_defaultedOut_defaultedOut_absent (void) = default;
+
+
+Small_defaultedOut_defaultedOut_absent Small_defaultedOut_defaultedOut_absent_var; /* global var */
+
+template int cbv<Small_defaultedOut_defaultedOut_absent> (Small_defaultedOut_defaultedOut_absent arg);
+/*** C++ class Large_defaultedOut_defaultedOut_absent ***/
+class Large_defaultedOut_defaultedOut_absent {
+public:
+  Large_defaultedOut_defaultedOut_absent (void);
+  Large_defaultedOut_defaultedOut_absent (const Large_defaultedOut_defaultedOut_absent &rhs);
+  ~Large_defaultedOut_defaultedOut_absent (void);
+
+
+  int data[150];
+};
+
+Large_defaultedOut_defaultedOut_absent::Large_defaultedOut_defaultedOut_absent (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedOut_defaultedOut_absent::Large_defaultedOut_defaultedOut_absent (const Large_defaultedOut_defaultedOut_absent &rhs) = default;
+Large_defaultedOut_defaultedOut_absent::~Large_defaultedOut_defaultedOut_absent (void) = default;
+
+
+Large_defaultedOut_defaultedOut_absent Large_defaultedOut_defaultedOut_absent_var; /* global var */
+
+template int cbv<Large_defaultedOut_defaultedOut_absent> (Large_defaultedOut_defaultedOut_absent arg);
+/*** Class derived from Small_defaultedOut_defaultedOut_absent ***/
+class Derived_defaultedOut_defaultedOut_absent : public Small_defaultedOut_defaultedOut_absent {
+public:
+};
+
+Derived_defaultedOut_defaultedOut_absent Derived_defaultedOut_defaultedOut_absent_var; /* global var */
+
+template int cbv<Derived_defaultedOut_defaultedOut_absent> (Derived_defaultedOut_defaultedOut_absent arg);
+/*** Class that contains Small_defaultedOut_defaultedOut_absent ***/
+class Container_defaultedOut_defaultedOut_absent {
+public:
+  Small_defaultedOut_defaultedOut_absent item;
+};
+
+Container_defaultedOut_defaultedOut_absent Container_defaultedOut_defaultedOut_absent_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_defaultedOut_absent> (Container_defaultedOut_defaultedOut_absent arg);
+/*** C++ class Small_defaultedOut_defaultedOut_explicit ***/
+class Small_defaultedOut_defaultedOut_explicit {
+public:
+  Small_defaultedOut_defaultedOut_explicit (void);
+  Small_defaultedOut_defaultedOut_explicit (const Small_defaultedOut_defaultedOut_explicit &rhs);
+  ~Small_defaultedOut_defaultedOut_explicit (void);
+  Small_defaultedOut_defaultedOut_explicit (Small_defaultedOut_defaultedOut_explicit &&rhs);
+
+
+  int data[2];
+};
+
+Small_defaultedOut_defaultedOut_explicit::Small_defaultedOut_defaultedOut_explicit (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedOut_defaultedOut_explicit::Small_defaultedOut_defaultedOut_explicit (const Small_defaultedOut_defaultedOut_explicit &rhs) = default;
+Small_defaultedOut_defaultedOut_explicit::~Small_defaultedOut_defaultedOut_explicit (void) = default;
+Small_defaultedOut_defaultedOut_explicit::Small_defaultedOut_defaultedOut_explicit (Small_defaultedOut_defaultedOut_explicit &&rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_defaultedOut_defaultedOut_explicit Small_defaultedOut_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Small_defaultedOut_defaultedOut_explicit> (Small_defaultedOut_defaultedOut_explicit arg);
+/*** C++ class Large_defaultedOut_defaultedOut_explicit ***/
+class Large_defaultedOut_defaultedOut_explicit {
+public:
+  Large_defaultedOut_defaultedOut_explicit (void);
+  Large_defaultedOut_defaultedOut_explicit (const Large_defaultedOut_defaultedOut_explicit &rhs);
+  ~Large_defaultedOut_defaultedOut_explicit (void);
+  Large_defaultedOut_defaultedOut_explicit (Large_defaultedOut_defaultedOut_explicit &&rhs);
+
+
+  int data[150];
+};
+
+Large_defaultedOut_defaultedOut_explicit::Large_defaultedOut_defaultedOut_explicit (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedOut_defaultedOut_explicit::Large_defaultedOut_defaultedOut_explicit (const Large_defaultedOut_defaultedOut_explicit &rhs) = default;
+Large_defaultedOut_defaultedOut_explicit::~Large_defaultedOut_defaultedOut_explicit (void) = default;
+Large_defaultedOut_defaultedOut_explicit::Large_defaultedOut_defaultedOut_explicit (Large_defaultedOut_defaultedOut_explicit &&rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_defaultedOut_defaultedOut_explicit Large_defaultedOut_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Large_defaultedOut_defaultedOut_explicit> (Large_defaultedOut_defaultedOut_explicit arg);
+/*** Class derived from Small_defaultedOut_defaultedOut_explicit ***/
+class Derived_defaultedOut_defaultedOut_explicit : public Small_defaultedOut_defaultedOut_explicit {
+public:
+};
+
+Derived_defaultedOut_defaultedOut_explicit Derived_defaultedOut_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Derived_defaultedOut_defaultedOut_explicit> (Derived_defaultedOut_defaultedOut_explicit arg);
+/*** Class that contains Small_defaultedOut_defaultedOut_explicit ***/
+class Container_defaultedOut_defaultedOut_explicit {
+public:
+  Small_defaultedOut_defaultedOut_explicit item;
+};
+
+Container_defaultedOut_defaultedOut_explicit Container_defaultedOut_defaultedOut_explicit_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_defaultedOut_explicit> (Container_defaultedOut_defaultedOut_explicit arg);
+/*** C++ class Small_defaultedOut_defaultedOut_defaultedIn ***/
+class Small_defaultedOut_defaultedOut_defaultedIn {
+public:
+  Small_defaultedOut_defaultedOut_defaultedIn (void);
+  Small_defaultedOut_defaultedOut_defaultedIn (const Small_defaultedOut_defaultedOut_defaultedIn &rhs);
+  ~Small_defaultedOut_defaultedOut_defaultedIn (void);
+  Small_defaultedOut_defaultedOut_defaultedIn (Small_defaultedOut_defaultedOut_defaultedIn &&rhs) = default;
+
+
+  int data[2];
+};
+
+Small_defaultedOut_defaultedOut_defaultedIn::Small_defaultedOut_defaultedOut_defaultedIn (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedOut_defaultedOut_defaultedIn::Small_defaultedOut_defaultedOut_defaultedIn (const Small_defaultedOut_defaultedOut_defaultedIn &rhs) = default;
+Small_defaultedOut_defaultedOut_defaultedIn::~Small_defaultedOut_defaultedOut_defaultedIn (void) = default;
+
+
+Small_defaultedOut_defaultedOut_defaultedIn Small_defaultedOut_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Small_defaultedOut_defaultedOut_defaultedIn> (Small_defaultedOut_defaultedOut_defaultedIn arg);
+/*** C++ class Large_defaultedOut_defaultedOut_defaultedIn ***/
+class Large_defaultedOut_defaultedOut_defaultedIn {
+public:
+  Large_defaultedOut_defaultedOut_defaultedIn (void);
+  Large_defaultedOut_defaultedOut_defaultedIn (const Large_defaultedOut_defaultedOut_defaultedIn &rhs);
+  ~Large_defaultedOut_defaultedOut_defaultedIn (void);
+  Large_defaultedOut_defaultedOut_defaultedIn (Large_defaultedOut_defaultedOut_defaultedIn &&rhs) = default;
+
+
+  int data[150];
+};
+
+Large_defaultedOut_defaultedOut_defaultedIn::Large_defaultedOut_defaultedOut_defaultedIn (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedOut_defaultedOut_defaultedIn::Large_defaultedOut_defaultedOut_defaultedIn (const Large_defaultedOut_defaultedOut_defaultedIn &rhs) = default;
+Large_defaultedOut_defaultedOut_defaultedIn::~Large_defaultedOut_defaultedOut_defaultedIn (void) = default;
+
+
+Large_defaultedOut_defaultedOut_defaultedIn Large_defaultedOut_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Large_defaultedOut_defaultedOut_defaultedIn> (Large_defaultedOut_defaultedOut_defaultedIn arg);
+/*** Class derived from Small_defaultedOut_defaultedOut_defaultedIn ***/
+class Derived_defaultedOut_defaultedOut_defaultedIn : public Small_defaultedOut_defaultedOut_defaultedIn {
+public:
+};
+
+Derived_defaultedOut_defaultedOut_defaultedIn Derived_defaultedOut_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Derived_defaultedOut_defaultedOut_defaultedIn> (Derived_defaultedOut_defaultedOut_defaultedIn arg);
+/*** Class that contains Small_defaultedOut_defaultedOut_defaultedIn ***/
+class Container_defaultedOut_defaultedOut_defaultedIn {
+public:
+  Small_defaultedOut_defaultedOut_defaultedIn item;
+};
+
+Container_defaultedOut_defaultedOut_defaultedIn Container_defaultedOut_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_defaultedOut_defaultedIn> (Container_defaultedOut_defaultedOut_defaultedIn arg);
+/*** C++ class Small_defaultedOut_defaultedOut_defaultedOut ***/
+class Small_defaultedOut_defaultedOut_defaultedOut {
+public:
+  Small_defaultedOut_defaultedOut_defaultedOut (void);
+  Small_defaultedOut_defaultedOut_defaultedOut (const Small_defaultedOut_defaultedOut_defaultedOut &rhs);
+  ~Small_defaultedOut_defaultedOut_defaultedOut (void);
+  Small_defaultedOut_defaultedOut_defaultedOut (Small_defaultedOut_defaultedOut_defaultedOut &&rhs);
+
+
+  int data[2];
+};
+
+Small_defaultedOut_defaultedOut_defaultedOut::Small_defaultedOut_defaultedOut_defaultedOut (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedOut_defaultedOut_defaultedOut::Small_defaultedOut_defaultedOut_defaultedOut (const Small_defaultedOut_defaultedOut_defaultedOut &rhs) = default;
+Small_defaultedOut_defaultedOut_defaultedOut::~Small_defaultedOut_defaultedOut_defaultedOut (void) = default;
+Small_defaultedOut_defaultedOut_defaultedOut::Small_defaultedOut_defaultedOut_defaultedOut (Small_defaultedOut_defaultedOut_defaultedOut &&rhs) = default;
+
+
+Small_defaultedOut_defaultedOut_defaultedOut Small_defaultedOut_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Small_defaultedOut_defaultedOut_defaultedOut> (Small_defaultedOut_defaultedOut_defaultedOut arg);
+/*** C++ class Large_defaultedOut_defaultedOut_defaultedOut ***/
+class Large_defaultedOut_defaultedOut_defaultedOut {
+public:
+  Large_defaultedOut_defaultedOut_defaultedOut (void);
+  Large_defaultedOut_defaultedOut_defaultedOut (const Large_defaultedOut_defaultedOut_defaultedOut &rhs);
+  ~Large_defaultedOut_defaultedOut_defaultedOut (void);
+  Large_defaultedOut_defaultedOut_defaultedOut (Large_defaultedOut_defaultedOut_defaultedOut &&rhs);
+
+
+  int data[150];
+};
+
+Large_defaultedOut_defaultedOut_defaultedOut::Large_defaultedOut_defaultedOut_defaultedOut (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedOut_defaultedOut_defaultedOut::Large_defaultedOut_defaultedOut_defaultedOut (const Large_defaultedOut_defaultedOut_defaultedOut &rhs) = default;
+Large_defaultedOut_defaultedOut_defaultedOut::~Large_defaultedOut_defaultedOut_defaultedOut (void) = default;
+Large_defaultedOut_defaultedOut_defaultedOut::Large_defaultedOut_defaultedOut_defaultedOut (Large_defaultedOut_defaultedOut_defaultedOut &&rhs) = default;
+
+
+Large_defaultedOut_defaultedOut_defaultedOut Large_defaultedOut_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Large_defaultedOut_defaultedOut_defaultedOut> (Large_defaultedOut_defaultedOut_defaultedOut arg);
+/*** Class derived from Small_defaultedOut_defaultedOut_defaultedOut ***/
+class Derived_defaultedOut_defaultedOut_defaultedOut : public Small_defaultedOut_defaultedOut_defaultedOut {
+public:
+};
+
+Derived_defaultedOut_defaultedOut_defaultedOut Derived_defaultedOut_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Derived_defaultedOut_defaultedOut_defaultedOut> (Derived_defaultedOut_defaultedOut_defaultedOut arg);
+/*** Class that contains Small_defaultedOut_defaultedOut_defaultedOut ***/
+class Container_defaultedOut_defaultedOut_defaultedOut {
+public:
+  Small_defaultedOut_defaultedOut_defaultedOut item;
+};
+
+Container_defaultedOut_defaultedOut_defaultedOut Container_defaultedOut_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_defaultedOut_defaultedOut> (Container_defaultedOut_defaultedOut_defaultedOut arg);
+/*** C++ class Small_defaultedOut_defaultedOut_deleted ***/
+class Small_defaultedOut_defaultedOut_deleted {
+public:
+  Small_defaultedOut_defaultedOut_deleted (void);
+  Small_defaultedOut_defaultedOut_deleted (const Small_defaultedOut_defaultedOut_deleted &rhs);
+  ~Small_defaultedOut_defaultedOut_deleted (void);
+  Small_defaultedOut_defaultedOut_deleted (Small_defaultedOut_defaultedOut_deleted &&rhs) = delete;
+
+
+  int data[2];
+};
+
+Small_defaultedOut_defaultedOut_deleted::Small_defaultedOut_defaultedOut_deleted (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_defaultedOut_defaultedOut_deleted::Small_defaultedOut_defaultedOut_deleted (const Small_defaultedOut_defaultedOut_deleted &rhs) = default;
+Small_defaultedOut_defaultedOut_deleted::~Small_defaultedOut_defaultedOut_deleted (void) = default;
+
+
+Small_defaultedOut_defaultedOut_deleted Small_defaultedOut_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Small_defaultedOut_defaultedOut_deleted> (Small_defaultedOut_defaultedOut_deleted arg);
+/*** C++ class Large_defaultedOut_defaultedOut_deleted ***/
+class Large_defaultedOut_defaultedOut_deleted {
+public:
+  Large_defaultedOut_defaultedOut_deleted (void);
+  Large_defaultedOut_defaultedOut_deleted (const Large_defaultedOut_defaultedOut_deleted &rhs);
+  ~Large_defaultedOut_defaultedOut_deleted (void);
+  Large_defaultedOut_defaultedOut_deleted (Large_defaultedOut_defaultedOut_deleted &&rhs) = delete;
+
+
+  int data[150];
+};
+
+Large_defaultedOut_defaultedOut_deleted::Large_defaultedOut_defaultedOut_deleted (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_defaultedOut_defaultedOut_deleted::Large_defaultedOut_defaultedOut_deleted (const Large_defaultedOut_defaultedOut_deleted &rhs) = default;
+Large_defaultedOut_defaultedOut_deleted::~Large_defaultedOut_defaultedOut_deleted (void) = default;
+
+
+Large_defaultedOut_defaultedOut_deleted Large_defaultedOut_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Large_defaultedOut_defaultedOut_deleted> (Large_defaultedOut_defaultedOut_deleted arg);
+/*** Class derived from Small_defaultedOut_defaultedOut_deleted ***/
+class Derived_defaultedOut_defaultedOut_deleted : public Small_defaultedOut_defaultedOut_deleted {
+public:
+};
+
+Derived_defaultedOut_defaultedOut_deleted Derived_defaultedOut_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Derived_defaultedOut_defaultedOut_deleted> (Derived_defaultedOut_defaultedOut_deleted arg);
+/*** Class that contains Small_defaultedOut_defaultedOut_deleted ***/
+class Container_defaultedOut_defaultedOut_deleted {
+public:
+  Small_defaultedOut_defaultedOut_deleted item;
+};
+
+Container_defaultedOut_defaultedOut_deleted Container_defaultedOut_defaultedOut_deleted_var; /* global var */
+
+template int cbv_container<Container_defaultedOut_defaultedOut_deleted> (Container_defaultedOut_defaultedOut_deleted arg);
+/*** C++ class Small_deleted_absent_absent ***/
+class Small_deleted_absent_absent {
+public:
+  Small_deleted_absent_absent (void);
+  Small_deleted_absent_absent (const Small_deleted_absent_absent &rhs) = delete;
+
+
+  int data[2];
+};
+
+Small_deleted_absent_absent::Small_deleted_absent_absent (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+
+
+Small_deleted_absent_absent Small_deleted_absent_absent_var; /* global var */
+
+template int cbv<Small_deleted_absent_absent> (Small_deleted_absent_absent arg);
+/*** C++ class Large_deleted_absent_absent ***/
+class Large_deleted_absent_absent {
+public:
+  Large_deleted_absent_absent (void);
+  Large_deleted_absent_absent (const Large_deleted_absent_absent &rhs) = delete;
+
+
+  int data[150];
+};
+
+Large_deleted_absent_absent::Large_deleted_absent_absent (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+
+
+Large_deleted_absent_absent Large_deleted_absent_absent_var; /* global var */
+
+template int cbv<Large_deleted_absent_absent> (Large_deleted_absent_absent arg);
+/*** Class derived from Small_deleted_absent_absent ***/
+class Derived_deleted_absent_absent : public Small_deleted_absent_absent {
+public:
+};
+
+Derived_deleted_absent_absent Derived_deleted_absent_absent_var; /* global var */
+
+template int cbv<Derived_deleted_absent_absent> (Derived_deleted_absent_absent arg);
+/*** Class that contains Small_deleted_absent_absent ***/
+class Container_deleted_absent_absent {
+public:
+  Small_deleted_absent_absent item;
+};
+
+Container_deleted_absent_absent Container_deleted_absent_absent_var; /* global var */
+
+template int cbv_container<Container_deleted_absent_absent> (Container_deleted_absent_absent arg);
+/*** C++ class Small_deleted_absent_explicit ***/
+class Small_deleted_absent_explicit {
+public:
+  Small_deleted_absent_explicit (void);
+  Small_deleted_absent_explicit (const Small_deleted_absent_explicit &rhs) = delete;
+  Small_deleted_absent_explicit (Small_deleted_absent_explicit &&rhs);
+
+
+  int data[2];
+};
+
+Small_deleted_absent_explicit::Small_deleted_absent_explicit (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_deleted_absent_explicit::Small_deleted_absent_explicit (Small_deleted_absent_explicit &&rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_deleted_absent_explicit Small_deleted_absent_explicit_var; /* global var */
+
+template int cbv<Small_deleted_absent_explicit> (Small_deleted_absent_explicit arg);
+/*** C++ class Large_deleted_absent_explicit ***/
+class Large_deleted_absent_explicit {
+public:
+  Large_deleted_absent_explicit (void);
+  Large_deleted_absent_explicit (const Large_deleted_absent_explicit &rhs) = delete;
+  Large_deleted_absent_explicit (Large_deleted_absent_explicit &&rhs);
+
+
+  int data[150];
+};
+
+Large_deleted_absent_explicit::Large_deleted_absent_explicit (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_deleted_absent_explicit::Large_deleted_absent_explicit (Large_deleted_absent_explicit &&rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_deleted_absent_explicit Large_deleted_absent_explicit_var; /* global var */
+
+template int cbv<Large_deleted_absent_explicit> (Large_deleted_absent_explicit arg);
+/*** Class derived from Small_deleted_absent_explicit ***/
+class Derived_deleted_absent_explicit : public Small_deleted_absent_explicit {
+public:
+};
+
+Derived_deleted_absent_explicit Derived_deleted_absent_explicit_var; /* global var */
+
+template int cbv<Derived_deleted_absent_explicit> (Derived_deleted_absent_explicit arg);
+/*** Class that contains Small_deleted_absent_explicit ***/
+class Container_deleted_absent_explicit {
+public:
+  Small_deleted_absent_explicit item;
+};
+
+Container_deleted_absent_explicit Container_deleted_absent_explicit_var; /* global var */
+
+template int cbv_container<Container_deleted_absent_explicit> (Container_deleted_absent_explicit arg);
+/*** C++ class Small_deleted_absent_defaultedIn ***/
+class Small_deleted_absent_defaultedIn {
+public:
+  Small_deleted_absent_defaultedIn (void);
+  Small_deleted_absent_defaultedIn (const Small_deleted_absent_defaultedIn &rhs) = delete;
+  Small_deleted_absent_defaultedIn (Small_deleted_absent_defaultedIn &&rhs) = default;
+
+
+  int data[2];
+};
+
+Small_deleted_absent_defaultedIn::Small_deleted_absent_defaultedIn (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+
+
+Small_deleted_absent_defaultedIn Small_deleted_absent_defaultedIn_var; /* global var */
+
+template int cbv<Small_deleted_absent_defaultedIn> (Small_deleted_absent_defaultedIn arg);
+/*** C++ class Large_deleted_absent_defaultedIn ***/
+class Large_deleted_absent_defaultedIn {
+public:
+  Large_deleted_absent_defaultedIn (void);
+  Large_deleted_absent_defaultedIn (const Large_deleted_absent_defaultedIn &rhs) = delete;
+  Large_deleted_absent_defaultedIn (Large_deleted_absent_defaultedIn &&rhs) = default;
+
+
+  int data[150];
+};
+
+Large_deleted_absent_defaultedIn::Large_deleted_absent_defaultedIn (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+
+
+Large_deleted_absent_defaultedIn Large_deleted_absent_defaultedIn_var; /* global var */
+
+template int cbv<Large_deleted_absent_defaultedIn> (Large_deleted_absent_defaultedIn arg);
+/*** Class derived from Small_deleted_absent_defaultedIn ***/
+class Derived_deleted_absent_defaultedIn : public Small_deleted_absent_defaultedIn {
+public:
+};
+
+Derived_deleted_absent_defaultedIn Derived_deleted_absent_defaultedIn_var; /* global var */
+
+template int cbv<Derived_deleted_absent_defaultedIn> (Derived_deleted_absent_defaultedIn arg);
+/*** Class that contains Small_deleted_absent_defaultedIn ***/
+class Container_deleted_absent_defaultedIn {
+public:
+  Small_deleted_absent_defaultedIn item;
+};
+
+Container_deleted_absent_defaultedIn Container_deleted_absent_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_deleted_absent_defaultedIn> (Container_deleted_absent_defaultedIn arg);
+/*** C++ class Small_deleted_absent_defaultedOut ***/
+class Small_deleted_absent_defaultedOut {
+public:
+  Small_deleted_absent_defaultedOut (void);
+  Small_deleted_absent_defaultedOut (const Small_deleted_absent_defaultedOut &rhs) = delete;
+  Small_deleted_absent_defaultedOut (Small_deleted_absent_defaultedOut &&rhs);
+
+
+  int data[2];
+};
+
+Small_deleted_absent_defaultedOut::Small_deleted_absent_defaultedOut (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_deleted_absent_defaultedOut::Small_deleted_absent_defaultedOut (Small_deleted_absent_defaultedOut &&rhs) = default;
+
+
+Small_deleted_absent_defaultedOut Small_deleted_absent_defaultedOut_var; /* global var */
+
+template int cbv<Small_deleted_absent_defaultedOut> (Small_deleted_absent_defaultedOut arg);
+/*** C++ class Large_deleted_absent_defaultedOut ***/
+class Large_deleted_absent_defaultedOut {
+public:
+  Large_deleted_absent_defaultedOut (void);
+  Large_deleted_absent_defaultedOut (const Large_deleted_absent_defaultedOut &rhs) = delete;
+  Large_deleted_absent_defaultedOut (Large_deleted_absent_defaultedOut &&rhs);
+
+
+  int data[150];
+};
+
+Large_deleted_absent_defaultedOut::Large_deleted_absent_defaultedOut (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_deleted_absent_defaultedOut::Large_deleted_absent_defaultedOut (Large_deleted_absent_defaultedOut &&rhs) = default;
+
+
+Large_deleted_absent_defaultedOut Large_deleted_absent_defaultedOut_var; /* global var */
+
+template int cbv<Large_deleted_absent_defaultedOut> (Large_deleted_absent_defaultedOut arg);
+/*** Class derived from Small_deleted_absent_defaultedOut ***/
+class Derived_deleted_absent_defaultedOut : public Small_deleted_absent_defaultedOut {
+public:
+};
+
+Derived_deleted_absent_defaultedOut Derived_deleted_absent_defaultedOut_var; /* global var */
+
+template int cbv<Derived_deleted_absent_defaultedOut> (Derived_deleted_absent_defaultedOut arg);
+/*** Class that contains Small_deleted_absent_defaultedOut ***/
+class Container_deleted_absent_defaultedOut {
+public:
+  Small_deleted_absent_defaultedOut item;
+};
+
+Container_deleted_absent_defaultedOut Container_deleted_absent_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_deleted_absent_defaultedOut> (Container_deleted_absent_defaultedOut arg);
+/*** C++ class Small_deleted_absent_deleted ***/
+class Small_deleted_absent_deleted {
+public:
+  Small_deleted_absent_deleted (void);
+  Small_deleted_absent_deleted (const Small_deleted_absent_deleted &rhs) = delete;
+  Small_deleted_absent_deleted (Small_deleted_absent_deleted &&rhs) = delete;
+
+
+  int data[2];
+};
+
+Small_deleted_absent_deleted::Small_deleted_absent_deleted (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+
+
+Small_deleted_absent_deleted Small_deleted_absent_deleted_var; /* global var */
+
+template int cbv<Small_deleted_absent_deleted> (Small_deleted_absent_deleted arg);
+/*** C++ class Large_deleted_absent_deleted ***/
+class Large_deleted_absent_deleted {
+public:
+  Large_deleted_absent_deleted (void);
+  Large_deleted_absent_deleted (const Large_deleted_absent_deleted &rhs) = delete;
+  Large_deleted_absent_deleted (Large_deleted_absent_deleted &&rhs) = delete;
+
+
+  int data[150];
+};
+
+Large_deleted_absent_deleted::Large_deleted_absent_deleted (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+
+
+Large_deleted_absent_deleted Large_deleted_absent_deleted_var; /* global var */
+
+template int cbv<Large_deleted_absent_deleted> (Large_deleted_absent_deleted arg);
+/*** Class derived from Small_deleted_absent_deleted ***/
+class Derived_deleted_absent_deleted : public Small_deleted_absent_deleted {
+public:
+};
+
+Derived_deleted_absent_deleted Derived_deleted_absent_deleted_var; /* global var */
+
+template int cbv<Derived_deleted_absent_deleted> (Derived_deleted_absent_deleted arg);
+/*** Class that contains Small_deleted_absent_deleted ***/
+class Container_deleted_absent_deleted {
+public:
+  Small_deleted_absent_deleted item;
+};
+
+Container_deleted_absent_deleted Container_deleted_absent_deleted_var; /* global var */
+
+template int cbv_container<Container_deleted_absent_deleted> (Container_deleted_absent_deleted arg);
+/*** C++ class Small_deleted_explicit_absent ***/
+class Small_deleted_explicit_absent {
+public:
+  Small_deleted_explicit_absent (void);
+  Small_deleted_explicit_absent (const Small_deleted_explicit_absent &rhs) = delete;
+  ~Small_deleted_explicit_absent (void);
+
+
+  int data[2];
+};
+
+Small_deleted_explicit_absent::Small_deleted_explicit_absent (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_deleted_explicit_absent::~Small_deleted_explicit_absent (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_deleted_explicit_absent Small_deleted_explicit_absent_var; /* global var */
+
+template int cbv<Small_deleted_explicit_absent> (Small_deleted_explicit_absent arg);
+/*** C++ class Large_deleted_explicit_absent ***/
+class Large_deleted_explicit_absent {
+public:
+  Large_deleted_explicit_absent (void);
+  Large_deleted_explicit_absent (const Large_deleted_explicit_absent &rhs) = delete;
+  ~Large_deleted_explicit_absent (void);
+
+
+  int data[150];
+};
+
+Large_deleted_explicit_absent::Large_deleted_explicit_absent (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_deleted_explicit_absent::~Large_deleted_explicit_absent (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_deleted_explicit_absent Large_deleted_explicit_absent_var; /* global var */
+
+template int cbv<Large_deleted_explicit_absent> (Large_deleted_explicit_absent arg);
+/*** Class derived from Small_deleted_explicit_absent ***/
+class Derived_deleted_explicit_absent : public Small_deleted_explicit_absent {
+public:
+};
+
+Derived_deleted_explicit_absent Derived_deleted_explicit_absent_var; /* global var */
+
+template int cbv<Derived_deleted_explicit_absent> (Derived_deleted_explicit_absent arg);
+/*** Class that contains Small_deleted_explicit_absent ***/
+class Container_deleted_explicit_absent {
+public:
+  Small_deleted_explicit_absent item;
+};
+
+Container_deleted_explicit_absent Container_deleted_explicit_absent_var; /* global var */
+
+template int cbv_container<Container_deleted_explicit_absent> (Container_deleted_explicit_absent arg);
+/*** C++ class Small_deleted_explicit_explicit ***/
+class Small_deleted_explicit_explicit {
+public:
+  Small_deleted_explicit_explicit (void);
+  Small_deleted_explicit_explicit (const Small_deleted_explicit_explicit &rhs) = delete;
+  ~Small_deleted_explicit_explicit (void);
+  Small_deleted_explicit_explicit (Small_deleted_explicit_explicit &&rhs);
+
+
+  int data[2];
+};
+
+Small_deleted_explicit_explicit::Small_deleted_explicit_explicit (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_deleted_explicit_explicit::~Small_deleted_explicit_explicit (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_deleted_explicit_explicit::Small_deleted_explicit_explicit (Small_deleted_explicit_explicit &&rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_deleted_explicit_explicit Small_deleted_explicit_explicit_var; /* global var */
+
+template int cbv<Small_deleted_explicit_explicit> (Small_deleted_explicit_explicit arg);
+/*** C++ class Large_deleted_explicit_explicit ***/
+class Large_deleted_explicit_explicit {
+public:
+  Large_deleted_explicit_explicit (void);
+  Large_deleted_explicit_explicit (const Large_deleted_explicit_explicit &rhs) = delete;
+  ~Large_deleted_explicit_explicit (void);
+  Large_deleted_explicit_explicit (Large_deleted_explicit_explicit &&rhs);
+
+
+  int data[150];
+};
+
+Large_deleted_explicit_explicit::Large_deleted_explicit_explicit (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_deleted_explicit_explicit::~Large_deleted_explicit_explicit (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_deleted_explicit_explicit::Large_deleted_explicit_explicit (Large_deleted_explicit_explicit &&rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_deleted_explicit_explicit Large_deleted_explicit_explicit_var; /* global var */
+
+template int cbv<Large_deleted_explicit_explicit> (Large_deleted_explicit_explicit arg);
+/*** Class derived from Small_deleted_explicit_explicit ***/
+class Derived_deleted_explicit_explicit : public Small_deleted_explicit_explicit {
+public:
+};
+
+Derived_deleted_explicit_explicit Derived_deleted_explicit_explicit_var; /* global var */
+
+template int cbv<Derived_deleted_explicit_explicit> (Derived_deleted_explicit_explicit arg);
+/*** Class that contains Small_deleted_explicit_explicit ***/
+class Container_deleted_explicit_explicit {
+public:
+  Small_deleted_explicit_explicit item;
+};
+
+Container_deleted_explicit_explicit Container_deleted_explicit_explicit_var; /* global var */
+
+template int cbv_container<Container_deleted_explicit_explicit> (Container_deleted_explicit_explicit arg);
+/*** C++ class Small_deleted_explicit_defaultedIn ***/
+class Small_deleted_explicit_defaultedIn {
+public:
+  Small_deleted_explicit_defaultedIn (void);
+  Small_deleted_explicit_defaultedIn (const Small_deleted_explicit_defaultedIn &rhs) = delete;
+  ~Small_deleted_explicit_defaultedIn (void);
+  Small_deleted_explicit_defaultedIn (Small_deleted_explicit_defaultedIn &&rhs) = default;
+
+
+  int data[2];
+};
+
+Small_deleted_explicit_defaultedIn::Small_deleted_explicit_defaultedIn (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_deleted_explicit_defaultedIn::~Small_deleted_explicit_defaultedIn (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_deleted_explicit_defaultedIn Small_deleted_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Small_deleted_explicit_defaultedIn> (Small_deleted_explicit_defaultedIn arg);
+/*** C++ class Large_deleted_explicit_defaultedIn ***/
+class Large_deleted_explicit_defaultedIn {
+public:
+  Large_deleted_explicit_defaultedIn (void);
+  Large_deleted_explicit_defaultedIn (const Large_deleted_explicit_defaultedIn &rhs) = delete;
+  ~Large_deleted_explicit_defaultedIn (void);
+  Large_deleted_explicit_defaultedIn (Large_deleted_explicit_defaultedIn &&rhs) = default;
+
+
+  int data[150];
+};
+
+Large_deleted_explicit_defaultedIn::Large_deleted_explicit_defaultedIn (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_deleted_explicit_defaultedIn::~Large_deleted_explicit_defaultedIn (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_deleted_explicit_defaultedIn Large_deleted_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Large_deleted_explicit_defaultedIn> (Large_deleted_explicit_defaultedIn arg);
+/*** Class derived from Small_deleted_explicit_defaultedIn ***/
+class Derived_deleted_explicit_defaultedIn : public Small_deleted_explicit_defaultedIn {
+public:
+};
+
+Derived_deleted_explicit_defaultedIn Derived_deleted_explicit_defaultedIn_var; /* global var */
+
+template int cbv<Derived_deleted_explicit_defaultedIn> (Derived_deleted_explicit_defaultedIn arg);
+/*** Class that contains Small_deleted_explicit_defaultedIn ***/
+class Container_deleted_explicit_defaultedIn {
+public:
+  Small_deleted_explicit_defaultedIn item;
+};
+
+Container_deleted_explicit_defaultedIn Container_deleted_explicit_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_deleted_explicit_defaultedIn> (Container_deleted_explicit_defaultedIn arg);
+/*** C++ class Small_deleted_explicit_defaultedOut ***/
+class Small_deleted_explicit_defaultedOut {
+public:
+  Small_deleted_explicit_defaultedOut (void);
+  Small_deleted_explicit_defaultedOut (const Small_deleted_explicit_defaultedOut &rhs) = delete;
+  ~Small_deleted_explicit_defaultedOut (void);
+  Small_deleted_explicit_defaultedOut (Small_deleted_explicit_defaultedOut &&rhs);
+
+
+  int data[2];
+};
+
+Small_deleted_explicit_defaultedOut::Small_deleted_explicit_defaultedOut (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_deleted_explicit_defaultedOut::~Small_deleted_explicit_defaultedOut (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+Small_deleted_explicit_defaultedOut::Small_deleted_explicit_defaultedOut (Small_deleted_explicit_defaultedOut &&rhs) = default;
+
+
+Small_deleted_explicit_defaultedOut Small_deleted_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Small_deleted_explicit_defaultedOut> (Small_deleted_explicit_defaultedOut arg);
+/*** C++ class Large_deleted_explicit_defaultedOut ***/
+class Large_deleted_explicit_defaultedOut {
+public:
+  Large_deleted_explicit_defaultedOut (void);
+  Large_deleted_explicit_defaultedOut (const Large_deleted_explicit_defaultedOut &rhs) = delete;
+  ~Large_deleted_explicit_defaultedOut (void);
+  Large_deleted_explicit_defaultedOut (Large_deleted_explicit_defaultedOut &&rhs);
+
+
+  int data[150];
+};
+
+Large_deleted_explicit_defaultedOut::Large_deleted_explicit_defaultedOut (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_deleted_explicit_defaultedOut::~Large_deleted_explicit_defaultedOut (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+Large_deleted_explicit_defaultedOut::Large_deleted_explicit_defaultedOut (Large_deleted_explicit_defaultedOut &&rhs) = default;
+
+
+Large_deleted_explicit_defaultedOut Large_deleted_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Large_deleted_explicit_defaultedOut> (Large_deleted_explicit_defaultedOut arg);
+/*** Class derived from Small_deleted_explicit_defaultedOut ***/
+class Derived_deleted_explicit_defaultedOut : public Small_deleted_explicit_defaultedOut {
+public:
+};
+
+Derived_deleted_explicit_defaultedOut Derived_deleted_explicit_defaultedOut_var; /* global var */
+
+template int cbv<Derived_deleted_explicit_defaultedOut> (Derived_deleted_explicit_defaultedOut arg);
+/*** Class that contains Small_deleted_explicit_defaultedOut ***/
+class Container_deleted_explicit_defaultedOut {
+public:
+  Small_deleted_explicit_defaultedOut item;
+};
+
+Container_deleted_explicit_defaultedOut Container_deleted_explicit_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_deleted_explicit_defaultedOut> (Container_deleted_explicit_defaultedOut arg);
+/*** C++ class Small_deleted_explicit_deleted ***/
+class Small_deleted_explicit_deleted {
+public:
+  Small_deleted_explicit_deleted (void);
+  Small_deleted_explicit_deleted (const Small_deleted_explicit_deleted &rhs) = delete;
+  ~Small_deleted_explicit_deleted (void);
+  Small_deleted_explicit_deleted (Small_deleted_explicit_deleted &&rhs) = delete;
+
+
+  int data[2];
+};
+
+Small_deleted_explicit_deleted::Small_deleted_explicit_deleted (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_deleted_explicit_deleted::~Small_deleted_explicit_deleted (void)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_deleted_explicit_deleted Small_deleted_explicit_deleted_var; /* global var */
+
+template int cbv<Small_deleted_explicit_deleted> (Small_deleted_explicit_deleted arg);
+/*** C++ class Large_deleted_explicit_deleted ***/
+class Large_deleted_explicit_deleted {
+public:
+  Large_deleted_explicit_deleted (void);
+  Large_deleted_explicit_deleted (const Large_deleted_explicit_deleted &rhs) = delete;
+  ~Large_deleted_explicit_deleted (void);
+  Large_deleted_explicit_deleted (Large_deleted_explicit_deleted &&rhs) = delete;
+
+
+  int data[150];
+};
+
+Large_deleted_explicit_deleted::Large_deleted_explicit_deleted (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_deleted_explicit_deleted::~Large_deleted_explicit_deleted (void)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_deleted_explicit_deleted Large_deleted_explicit_deleted_var; /* global var */
+
+template int cbv<Large_deleted_explicit_deleted> (Large_deleted_explicit_deleted arg);
+/*** Class derived from Small_deleted_explicit_deleted ***/
+class Derived_deleted_explicit_deleted : public Small_deleted_explicit_deleted {
+public:
+};
+
+Derived_deleted_explicit_deleted Derived_deleted_explicit_deleted_var; /* global var */
+
+template int cbv<Derived_deleted_explicit_deleted> (Derived_deleted_explicit_deleted arg);
+/*** Class that contains Small_deleted_explicit_deleted ***/
+class Container_deleted_explicit_deleted {
+public:
+  Small_deleted_explicit_deleted item;
+};
+
+Container_deleted_explicit_deleted Container_deleted_explicit_deleted_var; /* global var */
+
+template int cbv_container<Container_deleted_explicit_deleted> (Container_deleted_explicit_deleted arg);
+/*** C++ class Small_deleted_defaultedIn_absent ***/
+class Small_deleted_defaultedIn_absent {
+public:
+  Small_deleted_defaultedIn_absent (void);
+  Small_deleted_defaultedIn_absent (const Small_deleted_defaultedIn_absent &rhs) = delete;
+  ~Small_deleted_defaultedIn_absent (void) = default;
+
+
+  int data[2];
+};
+
+Small_deleted_defaultedIn_absent::Small_deleted_defaultedIn_absent (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+
+
+Small_deleted_defaultedIn_absent Small_deleted_defaultedIn_absent_var; /* global var */
+
+template int cbv<Small_deleted_defaultedIn_absent> (Small_deleted_defaultedIn_absent arg);
+/*** C++ class Large_deleted_defaultedIn_absent ***/
+class Large_deleted_defaultedIn_absent {
+public:
+  Large_deleted_defaultedIn_absent (void);
+  Large_deleted_defaultedIn_absent (const Large_deleted_defaultedIn_absent &rhs) = delete;
+  ~Large_deleted_defaultedIn_absent (void) = default;
+
+
+  int data[150];
+};
+
+Large_deleted_defaultedIn_absent::Large_deleted_defaultedIn_absent (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+
+
+Large_deleted_defaultedIn_absent Large_deleted_defaultedIn_absent_var; /* global var */
+
+template int cbv<Large_deleted_defaultedIn_absent> (Large_deleted_defaultedIn_absent arg);
+/*** Class derived from Small_deleted_defaultedIn_absent ***/
+class Derived_deleted_defaultedIn_absent : public Small_deleted_defaultedIn_absent {
+public:
+};
+
+Derived_deleted_defaultedIn_absent Derived_deleted_defaultedIn_absent_var; /* global var */
+
+template int cbv<Derived_deleted_defaultedIn_absent> (Derived_deleted_defaultedIn_absent arg);
+/*** Class that contains Small_deleted_defaultedIn_absent ***/
+class Container_deleted_defaultedIn_absent {
+public:
+  Small_deleted_defaultedIn_absent item;
+};
+
+Container_deleted_defaultedIn_absent Container_deleted_defaultedIn_absent_var; /* global var */
+
+template int cbv_container<Container_deleted_defaultedIn_absent> (Container_deleted_defaultedIn_absent arg);
+/*** C++ class Small_deleted_defaultedIn_explicit ***/
+class Small_deleted_defaultedIn_explicit {
+public:
+  Small_deleted_defaultedIn_explicit (void);
+  Small_deleted_defaultedIn_explicit (const Small_deleted_defaultedIn_explicit &rhs) = delete;
+  ~Small_deleted_defaultedIn_explicit (void) = default;
+  Small_deleted_defaultedIn_explicit (Small_deleted_defaultedIn_explicit &&rhs);
+
+
+  int data[2];
+};
+
+Small_deleted_defaultedIn_explicit::Small_deleted_defaultedIn_explicit (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_deleted_defaultedIn_explicit::Small_deleted_defaultedIn_explicit (Small_deleted_defaultedIn_explicit &&rhs)
+{
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
+}
+
+
+Small_deleted_defaultedIn_explicit Small_deleted_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Small_deleted_defaultedIn_explicit> (Small_deleted_defaultedIn_explicit arg);
+/*** C++ class Large_deleted_defaultedIn_explicit ***/
+class Large_deleted_defaultedIn_explicit {
+public:
+  Large_deleted_defaultedIn_explicit (void);
+  Large_deleted_defaultedIn_explicit (const Large_deleted_defaultedIn_explicit &rhs) = delete;
+  ~Large_deleted_defaultedIn_explicit (void) = default;
+  Large_deleted_defaultedIn_explicit (Large_deleted_defaultedIn_explicit &&rhs);
+
+
+  int data[150];
+};
+
+Large_deleted_defaultedIn_explicit::Large_deleted_defaultedIn_explicit (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_deleted_defaultedIn_explicit::Large_deleted_defaultedIn_explicit (Large_deleted_defaultedIn_explicit &&rhs)
+{
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
+}
+
+
+Large_deleted_defaultedIn_explicit Large_deleted_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Large_deleted_defaultedIn_explicit> (Large_deleted_defaultedIn_explicit arg);
+/*** Class derived from Small_deleted_defaultedIn_explicit ***/
+class Derived_deleted_defaultedIn_explicit : public Small_deleted_defaultedIn_explicit {
+public:
+};
+
+Derived_deleted_defaultedIn_explicit Derived_deleted_defaultedIn_explicit_var; /* global var */
+
+template int cbv<Derived_deleted_defaultedIn_explicit> (Derived_deleted_defaultedIn_explicit arg);
+/*** Class that contains Small_deleted_defaultedIn_explicit ***/
+class Container_deleted_defaultedIn_explicit {
+public:
+  Small_deleted_defaultedIn_explicit item;
+};
+
+Container_deleted_defaultedIn_explicit Container_deleted_defaultedIn_explicit_var; /* global var */
+
+template int cbv_container<Container_deleted_defaultedIn_explicit> (Container_deleted_defaultedIn_explicit arg);
+/*** C++ class Small_deleted_defaultedIn_defaultedIn ***/
+class Small_deleted_defaultedIn_defaultedIn {
+public:
+  Small_deleted_defaultedIn_defaultedIn (void);
+  Small_deleted_defaultedIn_defaultedIn (const Small_deleted_defaultedIn_defaultedIn &rhs) = delete;
+  ~Small_deleted_defaultedIn_defaultedIn (void) = default;
+  Small_deleted_defaultedIn_defaultedIn (Small_deleted_defaultedIn_defaultedIn &&rhs) = default;
+
+
+  int data[2];
+};
+
+Small_deleted_defaultedIn_defaultedIn::Small_deleted_defaultedIn_defaultedIn (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+
+
+Small_deleted_defaultedIn_defaultedIn Small_deleted_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Small_deleted_defaultedIn_defaultedIn> (Small_deleted_defaultedIn_defaultedIn arg);
+/*** C++ class Large_deleted_defaultedIn_defaultedIn ***/
+class Large_deleted_defaultedIn_defaultedIn {
+public:
+  Large_deleted_defaultedIn_defaultedIn (void);
+  Large_deleted_defaultedIn_defaultedIn (const Large_deleted_defaultedIn_defaultedIn &rhs) = delete;
+  ~Large_deleted_defaultedIn_defaultedIn (void) = default;
+  Large_deleted_defaultedIn_defaultedIn (Large_deleted_defaultedIn_defaultedIn &&rhs) = default;
+
+
+  int data[150];
+};
+
+Large_deleted_defaultedIn_defaultedIn::Large_deleted_defaultedIn_defaultedIn (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+
+
+Large_deleted_defaultedIn_defaultedIn Large_deleted_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Large_deleted_defaultedIn_defaultedIn> (Large_deleted_defaultedIn_defaultedIn arg);
+/*** Class derived from Small_deleted_defaultedIn_defaultedIn ***/
+class Derived_deleted_defaultedIn_defaultedIn : public Small_deleted_defaultedIn_defaultedIn {
+public:
+};
+
+Derived_deleted_defaultedIn_defaultedIn Derived_deleted_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv<Derived_deleted_defaultedIn_defaultedIn> (Derived_deleted_defaultedIn_defaultedIn arg);
+/*** Class that contains Small_deleted_defaultedIn_defaultedIn ***/
+class Container_deleted_defaultedIn_defaultedIn {
+public:
+  Small_deleted_defaultedIn_defaultedIn item;
+};
+
+Container_deleted_defaultedIn_defaultedIn Container_deleted_defaultedIn_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_deleted_defaultedIn_defaultedIn> (Container_deleted_defaultedIn_defaultedIn arg);
+/*** C++ class Small_deleted_defaultedIn_defaultedOut ***/
+class Small_deleted_defaultedIn_defaultedOut {
+public:
+  Small_deleted_defaultedIn_defaultedOut (void);
+  Small_deleted_defaultedIn_defaultedOut (const Small_deleted_defaultedIn_defaultedOut &rhs) = delete;
+  ~Small_deleted_defaultedIn_defaultedOut (void) = default;
+  Small_deleted_defaultedIn_defaultedOut (Small_deleted_defaultedIn_defaultedOut &&rhs);
+
+
+  int data[2];
+};
+
+Small_deleted_defaultedIn_defaultedOut::Small_deleted_defaultedIn_defaultedOut (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_deleted_defaultedIn_defaultedOut::Small_deleted_defaultedIn_defaultedOut (Small_deleted_defaultedIn_defaultedOut &&rhs) = default;
+
+
+Small_deleted_defaultedIn_defaultedOut Small_deleted_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Small_deleted_defaultedIn_defaultedOut> (Small_deleted_defaultedIn_defaultedOut arg);
+/*** C++ class Large_deleted_defaultedIn_defaultedOut ***/
+class Large_deleted_defaultedIn_defaultedOut {
+public:
+  Large_deleted_defaultedIn_defaultedOut (void);
+  Large_deleted_defaultedIn_defaultedOut (const Large_deleted_defaultedIn_defaultedOut &rhs) = delete;
+  ~Large_deleted_defaultedIn_defaultedOut (void) = default;
+  Large_deleted_defaultedIn_defaultedOut (Large_deleted_defaultedIn_defaultedOut &&rhs);
+
+
+  int data[150];
+};
+
+Large_deleted_defaultedIn_defaultedOut::Large_deleted_defaultedIn_defaultedOut (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_deleted_defaultedIn_defaultedOut::Large_deleted_defaultedIn_defaultedOut (Large_deleted_defaultedIn_defaultedOut &&rhs) = default;
+
+
+Large_deleted_defaultedIn_defaultedOut Large_deleted_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Large_deleted_defaultedIn_defaultedOut> (Large_deleted_defaultedIn_defaultedOut arg);
+/*** Class derived from Small_deleted_defaultedIn_defaultedOut ***/
+class Derived_deleted_defaultedIn_defaultedOut : public Small_deleted_defaultedIn_defaultedOut {
+public:
+};
+
+Derived_deleted_defaultedIn_defaultedOut Derived_deleted_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv<Derived_deleted_defaultedIn_defaultedOut> (Derived_deleted_defaultedIn_defaultedOut arg);
+/*** Class that contains Small_deleted_defaultedIn_defaultedOut ***/
+class Container_deleted_defaultedIn_defaultedOut {
+public:
+  Small_deleted_defaultedIn_defaultedOut item;
+};
+
+Container_deleted_defaultedIn_defaultedOut Container_deleted_defaultedIn_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_deleted_defaultedIn_defaultedOut> (Container_deleted_defaultedIn_defaultedOut arg);
+/*** C++ class Small_deleted_defaultedIn_deleted ***/
+class Small_deleted_defaultedIn_deleted {
+public:
+  Small_deleted_defaultedIn_deleted (void);
+  Small_deleted_defaultedIn_deleted (const Small_deleted_defaultedIn_deleted &rhs) = delete;
+  ~Small_deleted_defaultedIn_deleted (void) = default;
+  Small_deleted_defaultedIn_deleted (Small_deleted_defaultedIn_deleted &&rhs) = delete;
+
+
+  int data[2];
+};
+
+Small_deleted_defaultedIn_deleted::Small_deleted_defaultedIn_deleted (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+
+
+Small_deleted_defaultedIn_deleted Small_deleted_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Small_deleted_defaultedIn_deleted> (Small_deleted_defaultedIn_deleted arg);
+/*** C++ class Large_deleted_defaultedIn_deleted ***/
+class Large_deleted_defaultedIn_deleted {
+public:
+  Large_deleted_defaultedIn_deleted (void);
+  Large_deleted_defaultedIn_deleted (const Large_deleted_defaultedIn_deleted &rhs) = delete;
+  ~Large_deleted_defaultedIn_deleted (void) = default;
+  Large_deleted_defaultedIn_deleted (Large_deleted_defaultedIn_deleted &&rhs) = delete;
+
+
+  int data[150];
+};
+
+Large_deleted_defaultedIn_deleted::Large_deleted_defaultedIn_deleted (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+
+
+Large_deleted_defaultedIn_deleted Large_deleted_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Large_deleted_defaultedIn_deleted> (Large_deleted_defaultedIn_deleted arg);
+/*** Class derived from Small_deleted_defaultedIn_deleted ***/
+class Derived_deleted_defaultedIn_deleted : public Small_deleted_defaultedIn_deleted {
+public:
+};
+
+Derived_deleted_defaultedIn_deleted Derived_deleted_defaultedIn_deleted_var; /* global var */
+
+template int cbv<Derived_deleted_defaultedIn_deleted> (Derived_deleted_defaultedIn_deleted arg);
+/*** Class that contains Small_deleted_defaultedIn_deleted ***/
+class Container_deleted_defaultedIn_deleted {
+public:
+  Small_deleted_defaultedIn_deleted item;
+};
+
+Container_deleted_defaultedIn_deleted Container_deleted_defaultedIn_deleted_var; /* global var */
+
+template int cbv_container<Container_deleted_defaultedIn_deleted> (Container_deleted_defaultedIn_deleted arg);
+/*** C++ class Small_deleted_defaultedOut_absent ***/
+class Small_deleted_defaultedOut_absent {
+public:
+  Small_deleted_defaultedOut_absent (void);
+  Small_deleted_defaultedOut_absent (const Small_deleted_defaultedOut_absent &rhs) = delete;
+  ~Small_deleted_defaultedOut_absent (void);
+
+
+  int data[2];
+};
+
+Small_deleted_defaultedOut_absent::Small_deleted_defaultedOut_absent (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_deleted_defaultedOut_absent::~Small_deleted_defaultedOut_absent (void) = default;
+
+
+Small_deleted_defaultedOut_absent Small_deleted_defaultedOut_absent_var; /* global var */
+
+template int cbv<Small_deleted_defaultedOut_absent> (Small_deleted_defaultedOut_absent arg);
+/*** C++ class Large_deleted_defaultedOut_absent ***/
+class Large_deleted_defaultedOut_absent {
+public:
+  Large_deleted_defaultedOut_absent (void);
+  Large_deleted_defaultedOut_absent (const Large_deleted_defaultedOut_absent &rhs) = delete;
+  ~Large_deleted_defaultedOut_absent (void);
+
+
+  int data[150];
+};
+
+Large_deleted_defaultedOut_absent::Large_deleted_defaultedOut_absent (void)
+{
+  data[0] = 2;
+  data[149] = 2;
+}
+
+Large_deleted_defaultedOut_absent::~Large_deleted_defaultedOut_absent (void) = default;
+
+
+Large_deleted_defaultedOut_absent Large_deleted_defaultedOut_absent_var; /* global var */
+
+template int cbv<Large_deleted_defaultedOut_absent> (Large_deleted_defaultedOut_absent arg);
+/*** Class derived from Small_deleted_defaultedOut_absent ***/
+class Derived_deleted_defaultedOut_absent : public Small_deleted_defaultedOut_absent {
+public:
+};
+
+Derived_deleted_defaultedOut_absent Derived_deleted_defaultedOut_absent_var; /* global var */
+
+template int cbv<Derived_deleted_defaultedOut_absent> (Derived_deleted_defaultedOut_absent arg);
+/*** Class that contains Small_deleted_defaultedOut_absent ***/
+class Container_deleted_defaultedOut_absent {
+public:
+  Small_deleted_defaultedOut_absent item;
+};
+
+Container_deleted_defaultedOut_absent Container_deleted_defaultedOut_absent_var; /* global var */
+
+template int cbv_container<Container_deleted_defaultedOut_absent> (Container_deleted_defaultedOut_absent arg);
+/*** C++ class Small_deleted_defaultedOut_explicit ***/
+class Small_deleted_defaultedOut_explicit {
 public:
-  Obj ();
-  Obj (const Obj &);
-  ~Obj ();
-  int var[2];
+  Small_deleted_defaultedOut_explicit (void);
+  Small_deleted_defaultedOut_explicit (const Small_deleted_defaultedOut_explicit &rhs) = delete;
+  ~Small_deleted_defaultedOut_explicit (void);
+  Small_deleted_defaultedOut_explicit (Small_deleted_defaultedOut_explicit &&rhs);
+
+
+  int data[2];
 };
 
-int foo (Obj arg)
+Small_deleted_defaultedOut_explicit::Small_deleted_defaultedOut_explicit (void)
+{
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_deleted_defaultedOut_explicit::~Small_deleted_defaultedOut_explicit (void) = default;
+Small_deleted_defaultedOut_explicit::Small_deleted_defaultedOut_explicit (Small_deleted_defaultedOut_explicit &&rhs)
 {
-  return arg.var[0] + arg.var[1];
+  data[0] = 3;
+  data[1] = 3;
+  tracer = 5;
 }
 
-Obj::Obj ()
+
+Small_deleted_defaultedOut_explicit Small_deleted_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Small_deleted_defaultedOut_explicit> (Small_deleted_defaultedOut_explicit arg);
+/*** C++ class Large_deleted_defaultedOut_explicit ***/
+class Large_deleted_defaultedOut_explicit {
+public:
+  Large_deleted_defaultedOut_explicit (void);
+  Large_deleted_defaultedOut_explicit (const Large_deleted_defaultedOut_explicit &rhs) = delete;
+  ~Large_deleted_defaultedOut_explicit (void);
+  Large_deleted_defaultedOut_explicit (Large_deleted_defaultedOut_explicit &&rhs);
+
+
+  int data[150];
+};
+
+Large_deleted_defaultedOut_explicit::Large_deleted_defaultedOut_explicit (void)
 {
-  var[0] = 1;
-  var[1] = 2;
+  data[0] = 2;
+  data[149] = 2;
 }
 
-Obj::Obj (const Obj &obj)
+Large_deleted_defaultedOut_explicit::~Large_deleted_defaultedOut_explicit (void) = default;
+Large_deleted_defaultedOut_explicit::Large_deleted_defaultedOut_explicit (Large_deleted_defaultedOut_explicit &&rhs)
 {
-  var[0] = obj.var[0];
-  var[1] = obj.var[1];
+  data[0] = 3;
+  data[149] = 3;
+  tracer = 5;
 }
 
-Obj::~Obj ()
+
+Large_deleted_defaultedOut_explicit Large_deleted_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Large_deleted_defaultedOut_explicit> (Large_deleted_defaultedOut_explicit arg);
+/*** Class derived from Small_deleted_defaultedOut_explicit ***/
+class Derived_deleted_defaultedOut_explicit : public Small_deleted_defaultedOut_explicit {
+public:
+};
+
+Derived_deleted_defaultedOut_explicit Derived_deleted_defaultedOut_explicit_var; /* global var */
+
+template int cbv<Derived_deleted_defaultedOut_explicit> (Derived_deleted_defaultedOut_explicit arg);
+/*** Class that contains Small_deleted_defaultedOut_explicit ***/
+class Container_deleted_defaultedOut_explicit {
+public:
+  Small_deleted_defaultedOut_explicit item;
+};
+
+Container_deleted_defaultedOut_explicit Container_deleted_defaultedOut_explicit_var; /* global var */
+
+template int cbv_container<Container_deleted_defaultedOut_explicit> (Container_deleted_defaultedOut_explicit arg);
+/*** C++ class Small_deleted_defaultedOut_defaultedIn ***/
+class Small_deleted_defaultedOut_defaultedIn {
+public:
+  Small_deleted_defaultedOut_defaultedIn (void);
+  Small_deleted_defaultedOut_defaultedIn (const Small_deleted_defaultedOut_defaultedIn &rhs) = delete;
+  ~Small_deleted_defaultedOut_defaultedIn (void);
+  Small_deleted_defaultedOut_defaultedIn (Small_deleted_defaultedOut_defaultedIn &&rhs) = default;
+
+
+  int data[2];
+};
+
+Small_deleted_defaultedOut_defaultedIn::Small_deleted_defaultedOut_defaultedIn (void)
 {
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_deleted_defaultedOut_defaultedIn::~Small_deleted_defaultedOut_defaultedIn (void) = default;
+
+
+Small_deleted_defaultedOut_defaultedIn Small_deleted_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Small_deleted_defaultedOut_defaultedIn> (Small_deleted_defaultedOut_defaultedIn arg);
+/*** C++ class Large_deleted_defaultedOut_defaultedIn ***/
+class Large_deleted_defaultedOut_defaultedIn {
+public:
+  Large_deleted_defaultedOut_defaultedIn (void);
+  Large_deleted_defaultedOut_defaultedIn (const Large_deleted_defaultedOut_defaultedIn &rhs) = delete;
+  ~Large_deleted_defaultedOut_defaultedIn (void);
+  Large_deleted_defaultedOut_defaultedIn (Large_deleted_defaultedOut_defaultedIn &&rhs) = default;
+
+
+  int data[150];
+};
 
+Large_deleted_defaultedOut_defaultedIn::Large_deleted_defaultedOut_defaultedIn (void)
+{
+  data[0] = 2;
+  data[149] = 2;
 }
 
-struct Derived : public Obj
+Large_deleted_defaultedOut_defaultedIn::~Large_deleted_defaultedOut_defaultedIn (void) = default;
+
+
+Large_deleted_defaultedOut_defaultedIn Large_deleted_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Large_deleted_defaultedOut_defaultedIn> (Large_deleted_defaultedOut_defaultedIn arg);
+/*** Class derived from Small_deleted_defaultedOut_defaultedIn ***/
+class Derived_deleted_defaultedOut_defaultedIn : public Small_deleted_defaultedOut_defaultedIn {
+public:
+};
+
+Derived_deleted_defaultedOut_defaultedIn Derived_deleted_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv<Derived_deleted_defaultedOut_defaultedIn> (Derived_deleted_defaultedOut_defaultedIn arg);
+/*** Class that contains Small_deleted_defaultedOut_defaultedIn ***/
+class Container_deleted_defaultedOut_defaultedIn {
+public:
+  Small_deleted_defaultedOut_defaultedIn item;
+};
+
+Container_deleted_defaultedOut_defaultedIn Container_deleted_defaultedOut_defaultedIn_var; /* global var */
+
+template int cbv_container<Container_deleted_defaultedOut_defaultedIn> (Container_deleted_defaultedOut_defaultedIn arg);
+/*** C++ class Small_deleted_defaultedOut_defaultedOut ***/
+class Small_deleted_defaultedOut_defaultedOut {
+public:
+  Small_deleted_defaultedOut_defaultedOut (void);
+  Small_deleted_defaultedOut_defaultedOut (const Small_deleted_defaultedOut_defaultedOut &rhs) = delete;
+  ~Small_deleted_defaultedOut_defaultedOut (void);
+  Small_deleted_defaultedOut_defaultedOut (Small_deleted_defaultedOut_defaultedOut &&rhs);
+
+
+  int data[2];
+};
+
+Small_deleted_defaultedOut_defaultedOut::Small_deleted_defaultedOut_defaultedOut (void)
 {
-  int other;
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_deleted_defaultedOut_defaultedOut::~Small_deleted_defaultedOut_defaultedOut (void) = default;
+Small_deleted_defaultedOut_defaultedOut::Small_deleted_defaultedOut_defaultedOut (Small_deleted_defaultedOut_defaultedOut &&rhs) = default;
+
+
+Small_deleted_defaultedOut_defaultedOut Small_deleted_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Small_deleted_defaultedOut_defaultedOut> (Small_deleted_defaultedOut_defaultedOut arg);
+/*** C++ class Large_deleted_defaultedOut_defaultedOut ***/
+class Large_deleted_defaultedOut_defaultedOut {
+public:
+  Large_deleted_defaultedOut_defaultedOut (void);
+  Large_deleted_defaultedOut_defaultedOut (const Large_deleted_defaultedOut_defaultedOut &rhs) = delete;
+  ~Large_deleted_defaultedOut_defaultedOut (void);
+  Large_deleted_defaultedOut_defaultedOut (Large_deleted_defaultedOut_defaultedOut &&rhs);
+
+
+  int data[150];
 };
 
-int blap (Derived arg)
+Large_deleted_defaultedOut_defaultedOut::Large_deleted_defaultedOut_defaultedOut (void)
 {
-  return foo (arg);
+  data[0] = 2;
+  data[149] = 2;
 }
 
-struct Container
+Large_deleted_defaultedOut_defaultedOut::~Large_deleted_defaultedOut_defaultedOut (void) = default;
+Large_deleted_defaultedOut_defaultedOut::Large_deleted_defaultedOut_defaultedOut (Large_deleted_defaultedOut_defaultedOut &&rhs) = default;
+
+
+Large_deleted_defaultedOut_defaultedOut Large_deleted_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Large_deleted_defaultedOut_defaultedOut> (Large_deleted_defaultedOut_defaultedOut arg);
+/*** Class derived from Small_deleted_defaultedOut_defaultedOut ***/
+class Derived_deleted_defaultedOut_defaultedOut : public Small_deleted_defaultedOut_defaultedOut {
+public:
+};
+
+Derived_deleted_defaultedOut_defaultedOut Derived_deleted_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv<Derived_deleted_defaultedOut_defaultedOut> (Derived_deleted_defaultedOut_defaultedOut arg);
+/*** Class that contains Small_deleted_defaultedOut_defaultedOut ***/
+class Container_deleted_defaultedOut_defaultedOut {
+public:
+  Small_deleted_defaultedOut_defaultedOut item;
+};
+
+Container_deleted_defaultedOut_defaultedOut Container_deleted_defaultedOut_defaultedOut_var; /* global var */
+
+template int cbv_container<Container_deleted_defaultedOut_defaultedOut> (Container_deleted_defaultedOut_defaultedOut arg);
+/*** C++ class Small_deleted_defaultedOut_deleted ***/
+class Small_deleted_defaultedOut_deleted {
+public:
+  Small_deleted_defaultedOut_deleted (void);
+  Small_deleted_defaultedOut_deleted (const Small_deleted_defaultedOut_deleted &rhs) = delete;
+  ~Small_deleted_defaultedOut_deleted (void);
+  Small_deleted_defaultedOut_deleted (Small_deleted_defaultedOut_deleted &&rhs) = delete;
+
+
+  int data[2];
+};
+
+Small_deleted_defaultedOut_deleted::Small_deleted_defaultedOut_deleted (void)
 {
-  Obj obj;
+  data[0] = 2;
+  data[1] = 2;
+}
+
+Small_deleted_defaultedOut_deleted::~Small_deleted_defaultedOut_deleted (void) = default;
+
+
+Small_deleted_defaultedOut_deleted Small_deleted_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Small_deleted_defaultedOut_deleted> (Small_deleted_defaultedOut_deleted arg);
+/*** C++ class Large_deleted_defaultedOut_deleted ***/
+class Large_deleted_defaultedOut_deleted {
+public:
+  Large_deleted_defaultedOut_deleted (void);
+  Large_deleted_defaultedOut_deleted (const Large_deleted_defaultedOut_deleted &rhs) = delete;
+  ~Large_deleted_defaultedOut_deleted (void);
+  Large_deleted_defaultedOut_deleted (Large_deleted_defaultedOut_deleted &&rhs) = delete;
+
+
+  int data[150];
 };
 
-int blip (Container arg)
+Large_deleted_defaultedOut_deleted::Large_deleted_defaultedOut_deleted (void)
 {
-  return foo (arg.obj);
+  data[0] = 2;
+  data[149] = 2;
 }
 
-Obj global_obj;
-Derived global_derived;
-Container global_container;
+Large_deleted_defaultedOut_deleted::~Large_deleted_defaultedOut_deleted (void) = default;
+
+
+Large_deleted_defaultedOut_deleted Large_deleted_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Large_deleted_defaultedOut_deleted> (Large_deleted_defaultedOut_deleted arg);
+/*** Class derived from Small_deleted_defaultedOut_deleted ***/
+class Derived_deleted_defaultedOut_deleted : public Small_deleted_defaultedOut_deleted {
+public:
+};
+
+Derived_deleted_defaultedOut_deleted Derived_deleted_defaultedOut_deleted_var; /* global var */
+
+template int cbv<Derived_deleted_defaultedOut_deleted> (Derived_deleted_defaultedOut_deleted arg);
+/*** Class that contains Small_deleted_defaultedOut_deleted ***/
+class Container_deleted_defaultedOut_deleted {
+public:
+  Small_deleted_defaultedOut_deleted item;
+};
+
+Container_deleted_defaultedOut_deleted Container_deleted_defaultedOut_deleted_var; /* global var */
+
+template int cbv_container<Container_deleted_defaultedOut_deleted> (Container_deleted_defaultedOut_deleted arg);
 
 int
-main ()
+main (void)
 {
-  int bar = foo (global_obj);
-  blap (global_derived);
-  blip (global_container);
-  return bar;
+  cbv<Small_absent_absent_absent> (Small_absent_absent_absent_var);
+  cbv<Large_absent_absent_absent> (Large_absent_absent_absent_var);
+  cbv<Derived_absent_absent_absent> (Derived_absent_absent_absent_var);
+  cbv_container<Container_absent_absent_absent> (Container_absent_absent_absent_var);
+  cbv<Small_absent_explicit_absent> (Small_absent_explicit_absent_var);
+  cbv<Large_absent_explicit_absent> (Large_absent_explicit_absent_var);
+  cbv<Derived_absent_explicit_absent> (Derived_absent_explicit_absent_var);
+  cbv_container<Container_absent_explicit_absent> (Container_absent_explicit_absent_var);
+  cbv<Small_absent_defaultedIn_absent> (Small_absent_defaultedIn_absent_var);
+  cbv<Large_absent_defaultedIn_absent> (Large_absent_defaultedIn_absent_var);
+  cbv<Derived_absent_defaultedIn_absent> (Derived_absent_defaultedIn_absent_var);
+  cbv_container<Container_absent_defaultedIn_absent> (Container_absent_defaultedIn_absent_var);
+  cbv<Small_absent_defaultedOut_absent> (Small_absent_defaultedOut_absent_var);
+  cbv<Large_absent_defaultedOut_absent> (Large_absent_defaultedOut_absent_var);
+  cbv<Derived_absent_defaultedOut_absent> (Derived_absent_defaultedOut_absent_var);
+  cbv_container<Container_absent_defaultedOut_absent> (Container_absent_defaultedOut_absent_var);
+  cbv<Small_explicit_absent_absent> (Small_explicit_absent_absent_var);
+  cbv<Large_explicit_absent_absent> (Large_explicit_absent_absent_var);
+  cbv<Derived_explicit_absent_absent> (Derived_explicit_absent_absent_var);
+  cbv_container<Container_explicit_absent_absent> (Container_explicit_absent_absent_var);
+  cbv<Small_explicit_absent_explicit> (Small_explicit_absent_explicit_var);
+  cbv<Large_explicit_absent_explicit> (Large_explicit_absent_explicit_var);
+  cbv<Derived_explicit_absent_explicit> (Derived_explicit_absent_explicit_var);
+  cbv_container<Container_explicit_absent_explicit> (Container_explicit_absent_explicit_var);
+  cbv<Small_explicit_absent_defaultedIn> (Small_explicit_absent_defaultedIn_var);
+  cbv<Large_explicit_absent_defaultedIn> (Large_explicit_absent_defaultedIn_var);
+  cbv<Derived_explicit_absent_defaultedIn> (Derived_explicit_absent_defaultedIn_var);
+  cbv_container<Container_explicit_absent_defaultedIn> (Container_explicit_absent_defaultedIn_var);
+  cbv<Small_explicit_absent_defaultedOut> (Small_explicit_absent_defaultedOut_var);
+  cbv<Large_explicit_absent_defaultedOut> (Large_explicit_absent_defaultedOut_var);
+  cbv<Derived_explicit_absent_defaultedOut> (Derived_explicit_absent_defaultedOut_var);
+  cbv_container<Container_explicit_absent_defaultedOut> (Container_explicit_absent_defaultedOut_var);
+  cbv<Small_explicit_absent_deleted> (Small_explicit_absent_deleted_var);
+  cbv<Large_explicit_absent_deleted> (Large_explicit_absent_deleted_var);
+  cbv<Derived_explicit_absent_deleted> (Derived_explicit_absent_deleted_var);
+  cbv_container<Container_explicit_absent_deleted> (Container_explicit_absent_deleted_var);
+  cbv<Small_explicit_explicit_absent> (Small_explicit_explicit_absent_var);
+  cbv<Large_explicit_explicit_absent> (Large_explicit_explicit_absent_var);
+  cbv<Derived_explicit_explicit_absent> (Derived_explicit_explicit_absent_var);
+  cbv_container<Container_explicit_explicit_absent> (Container_explicit_explicit_absent_var);
+  cbv<Small_explicit_explicit_explicit> (Small_explicit_explicit_explicit_var);
+  cbv<Large_explicit_explicit_explicit> (Large_explicit_explicit_explicit_var);
+  cbv<Derived_explicit_explicit_explicit> (Derived_explicit_explicit_explicit_var);
+  cbv_container<Container_explicit_explicit_explicit> (Container_explicit_explicit_explicit_var);
+  cbv<Small_explicit_explicit_defaultedIn> (Small_explicit_explicit_defaultedIn_var);
+  cbv<Large_explicit_explicit_defaultedIn> (Large_explicit_explicit_defaultedIn_var);
+  cbv<Derived_explicit_explicit_defaultedIn> (Derived_explicit_explicit_defaultedIn_var);
+  cbv_container<Container_explicit_explicit_defaultedIn> (Container_explicit_explicit_defaultedIn_var);
+  cbv<Small_explicit_explicit_defaultedOut> (Small_explicit_explicit_defaultedOut_var);
+  cbv<Large_explicit_explicit_defaultedOut> (Large_explicit_explicit_defaultedOut_var);
+  cbv<Derived_explicit_explicit_defaultedOut> (Derived_explicit_explicit_defaultedOut_var);
+  cbv_container<Container_explicit_explicit_defaultedOut> (Container_explicit_explicit_defaultedOut_var);
+  cbv<Small_explicit_explicit_deleted> (Small_explicit_explicit_deleted_var);
+  cbv<Large_explicit_explicit_deleted> (Large_explicit_explicit_deleted_var);
+  cbv<Derived_explicit_explicit_deleted> (Derived_explicit_explicit_deleted_var);
+  cbv_container<Container_explicit_explicit_deleted> (Container_explicit_explicit_deleted_var);
+  cbv<Small_explicit_defaultedIn_absent> (Small_explicit_defaultedIn_absent_var);
+  cbv<Large_explicit_defaultedIn_absent> (Large_explicit_defaultedIn_absent_var);
+  cbv<Derived_explicit_defaultedIn_absent> (Derived_explicit_defaultedIn_absent_var);
+  cbv_container<Container_explicit_defaultedIn_absent> (Container_explicit_defaultedIn_absent_var);
+  cbv<Small_explicit_defaultedIn_explicit> (Small_explicit_defaultedIn_explicit_var);
+  cbv<Large_explicit_defaultedIn_explicit> (Large_explicit_defaultedIn_explicit_var);
+  cbv<Derived_explicit_defaultedIn_explicit> (Derived_explicit_defaultedIn_explicit_var);
+  cbv_container<Container_explicit_defaultedIn_explicit> (Container_explicit_defaultedIn_explicit_var);
+  cbv<Small_explicit_defaultedIn_defaultedIn> (Small_explicit_defaultedIn_defaultedIn_var);
+  cbv<Large_explicit_defaultedIn_defaultedIn> (Large_explicit_defaultedIn_defaultedIn_var);
+  cbv<Derived_explicit_defaultedIn_defaultedIn> (Derived_explicit_defaultedIn_defaultedIn_var);
+  cbv_container<Container_explicit_defaultedIn_defaultedIn> (Container_explicit_defaultedIn_defaultedIn_var);
+  cbv<Small_explicit_defaultedIn_defaultedOut> (Small_explicit_defaultedIn_defaultedOut_var);
+  cbv<Large_explicit_defaultedIn_defaultedOut> (Large_explicit_defaultedIn_defaultedOut_var);
+  cbv<Derived_explicit_defaultedIn_defaultedOut> (Derived_explicit_defaultedIn_defaultedOut_var);
+  cbv_container<Container_explicit_defaultedIn_defaultedOut> (Container_explicit_defaultedIn_defaultedOut_var);
+  cbv<Small_explicit_defaultedIn_deleted> (Small_explicit_defaultedIn_deleted_var);
+  cbv<Large_explicit_defaultedIn_deleted> (Large_explicit_defaultedIn_deleted_var);
+  cbv<Derived_explicit_defaultedIn_deleted> (Derived_explicit_defaultedIn_deleted_var);
+  cbv_container<Container_explicit_defaultedIn_deleted> (Container_explicit_defaultedIn_deleted_var);
+  cbv<Small_explicit_defaultedOut_absent> (Small_explicit_defaultedOut_absent_var);
+  cbv<Large_explicit_defaultedOut_absent> (Large_explicit_defaultedOut_absent_var);
+  cbv<Derived_explicit_defaultedOut_absent> (Derived_explicit_defaultedOut_absent_var);
+  cbv_container<Container_explicit_defaultedOut_absent> (Container_explicit_defaultedOut_absent_var);
+  cbv<Small_explicit_defaultedOut_explicit> (Small_explicit_defaultedOut_explicit_var);
+  cbv<Large_explicit_defaultedOut_explicit> (Large_explicit_defaultedOut_explicit_var);
+  cbv<Derived_explicit_defaultedOut_explicit> (Derived_explicit_defaultedOut_explicit_var);
+  cbv_container<Container_explicit_defaultedOut_explicit> (Container_explicit_defaultedOut_explicit_var);
+  cbv<Small_explicit_defaultedOut_defaultedIn> (Small_explicit_defaultedOut_defaultedIn_var);
+  cbv<Large_explicit_defaultedOut_defaultedIn> (Large_explicit_defaultedOut_defaultedIn_var);
+  cbv<Derived_explicit_defaultedOut_defaultedIn> (Derived_explicit_defaultedOut_defaultedIn_var);
+  cbv_container<Container_explicit_defaultedOut_defaultedIn> (Container_explicit_defaultedOut_defaultedIn_var);
+  cbv<Small_explicit_defaultedOut_defaultedOut> (Small_explicit_defaultedOut_defaultedOut_var);
+  cbv<Large_explicit_defaultedOut_defaultedOut> (Large_explicit_defaultedOut_defaultedOut_var);
+  cbv<Derived_explicit_defaultedOut_defaultedOut> (Derived_explicit_defaultedOut_defaultedOut_var);
+  cbv_container<Container_explicit_defaultedOut_defaultedOut> (Container_explicit_defaultedOut_defaultedOut_var);
+  cbv<Small_explicit_defaultedOut_deleted> (Small_explicit_defaultedOut_deleted_var);
+  cbv<Large_explicit_defaultedOut_deleted> (Large_explicit_defaultedOut_deleted_var);
+  cbv<Derived_explicit_defaultedOut_deleted> (Derived_explicit_defaultedOut_deleted_var);
+  cbv_container<Container_explicit_defaultedOut_deleted> (Container_explicit_defaultedOut_deleted_var);
+  cbv<Small_defaultedIn_absent_absent> (Small_defaultedIn_absent_absent_var);
+  cbv<Large_defaultedIn_absent_absent> (Large_defaultedIn_absent_absent_var);
+  cbv<Derived_defaultedIn_absent_absent> (Derived_defaultedIn_absent_absent_var);
+  cbv_container<Container_defaultedIn_absent_absent> (Container_defaultedIn_absent_absent_var);
+  cbv<Small_defaultedIn_absent_explicit> (Small_defaultedIn_absent_explicit_var);
+  cbv<Large_defaultedIn_absent_explicit> (Large_defaultedIn_absent_explicit_var);
+  cbv<Derived_defaultedIn_absent_explicit> (Derived_defaultedIn_absent_explicit_var);
+  cbv_container<Container_defaultedIn_absent_explicit> (Container_defaultedIn_absent_explicit_var);
+  cbv<Small_defaultedIn_absent_defaultedIn> (Small_defaultedIn_absent_defaultedIn_var);
+  cbv<Large_defaultedIn_absent_defaultedIn> (Large_defaultedIn_absent_defaultedIn_var);
+  cbv<Derived_defaultedIn_absent_defaultedIn> (Derived_defaultedIn_absent_defaultedIn_var);
+  cbv_container<Container_defaultedIn_absent_defaultedIn> (Container_defaultedIn_absent_defaultedIn_var);
+  cbv<Small_defaultedIn_absent_defaultedOut> (Small_defaultedIn_absent_defaultedOut_var);
+  cbv<Large_defaultedIn_absent_defaultedOut> (Large_defaultedIn_absent_defaultedOut_var);
+  cbv<Derived_defaultedIn_absent_defaultedOut> (Derived_defaultedIn_absent_defaultedOut_var);
+  cbv_container<Container_defaultedIn_absent_defaultedOut> (Container_defaultedIn_absent_defaultedOut_var);
+  cbv<Small_defaultedIn_absent_deleted> (Small_defaultedIn_absent_deleted_var);
+  cbv<Large_defaultedIn_absent_deleted> (Large_defaultedIn_absent_deleted_var);
+  cbv<Derived_defaultedIn_absent_deleted> (Derived_defaultedIn_absent_deleted_var);
+  cbv_container<Container_defaultedIn_absent_deleted> (Container_defaultedIn_absent_deleted_var);
+  cbv<Small_defaultedIn_explicit_absent> (Small_defaultedIn_explicit_absent_var);
+  cbv<Large_defaultedIn_explicit_absent> (Large_defaultedIn_explicit_absent_var);
+  cbv<Derived_defaultedIn_explicit_absent> (Derived_defaultedIn_explicit_absent_var);
+  cbv_container<Container_defaultedIn_explicit_absent> (Container_defaultedIn_explicit_absent_var);
+  cbv<Small_defaultedIn_explicit_explicit> (Small_defaultedIn_explicit_explicit_var);
+  cbv<Large_defaultedIn_explicit_explicit> (Large_defaultedIn_explicit_explicit_var);
+  cbv<Derived_defaultedIn_explicit_explicit> (Derived_defaultedIn_explicit_explicit_var);
+  cbv_container<Container_defaultedIn_explicit_explicit> (Container_defaultedIn_explicit_explicit_var);
+  cbv<Small_defaultedIn_explicit_defaultedIn> (Small_defaultedIn_explicit_defaultedIn_var);
+  cbv<Large_defaultedIn_explicit_defaultedIn> (Large_defaultedIn_explicit_defaultedIn_var);
+  cbv<Derived_defaultedIn_explicit_defaultedIn> (Derived_defaultedIn_explicit_defaultedIn_var);
+  cbv_container<Container_defaultedIn_explicit_defaultedIn> (Container_defaultedIn_explicit_defaultedIn_var);
+  cbv<Small_defaultedIn_explicit_defaultedOut> (Small_defaultedIn_explicit_defaultedOut_var);
+  cbv<Large_defaultedIn_explicit_defaultedOut> (Large_defaultedIn_explicit_defaultedOut_var);
+  cbv<Derived_defaultedIn_explicit_defaultedOut> (Derived_defaultedIn_explicit_defaultedOut_var);
+  cbv_container<Container_defaultedIn_explicit_defaultedOut> (Container_defaultedIn_explicit_defaultedOut_var);
+  cbv<Small_defaultedIn_explicit_deleted> (Small_defaultedIn_explicit_deleted_var);
+  cbv<Large_defaultedIn_explicit_deleted> (Large_defaultedIn_explicit_deleted_var);
+  cbv<Derived_defaultedIn_explicit_deleted> (Derived_defaultedIn_explicit_deleted_var);
+  cbv_container<Container_defaultedIn_explicit_deleted> (Container_defaultedIn_explicit_deleted_var);
+  cbv<Small_defaultedIn_defaultedIn_absent> (Small_defaultedIn_defaultedIn_absent_var);
+  cbv<Large_defaultedIn_defaultedIn_absent> (Large_defaultedIn_defaultedIn_absent_var);
+  cbv<Derived_defaultedIn_defaultedIn_absent> (Derived_defaultedIn_defaultedIn_absent_var);
+  cbv_container<Container_defaultedIn_defaultedIn_absent> (Container_defaultedIn_defaultedIn_absent_var);
+  cbv<Small_defaultedIn_defaultedIn_explicit> (Small_defaultedIn_defaultedIn_explicit_var);
+  cbv<Large_defaultedIn_defaultedIn_explicit> (Large_defaultedIn_defaultedIn_explicit_var);
+  cbv<Derived_defaultedIn_defaultedIn_explicit> (Derived_defaultedIn_defaultedIn_explicit_var);
+  cbv_container<Container_defaultedIn_defaultedIn_explicit> (Container_defaultedIn_defaultedIn_explicit_var);
+  cbv<Small_defaultedIn_defaultedIn_defaultedIn> (Small_defaultedIn_defaultedIn_defaultedIn_var);
+  cbv<Large_defaultedIn_defaultedIn_defaultedIn> (Large_defaultedIn_defaultedIn_defaultedIn_var);
+  cbv<Derived_defaultedIn_defaultedIn_defaultedIn> (Derived_defaultedIn_defaultedIn_defaultedIn_var);
+  cbv_container<Container_defaultedIn_defaultedIn_defaultedIn> (Container_defaultedIn_defaultedIn_defaultedIn_var);
+  cbv<Small_defaultedIn_defaultedIn_defaultedOut> (Small_defaultedIn_defaultedIn_defaultedOut_var);
+  cbv<Large_defaultedIn_defaultedIn_defaultedOut> (Large_defaultedIn_defaultedIn_defaultedOut_var);
+  cbv<Derived_defaultedIn_defaultedIn_defaultedOut> (Derived_defaultedIn_defaultedIn_defaultedOut_var);
+  cbv_container<Container_defaultedIn_defaultedIn_defaultedOut> (Container_defaultedIn_defaultedIn_defaultedOut_var);
+  cbv<Small_defaultedIn_defaultedIn_deleted> (Small_defaultedIn_defaultedIn_deleted_var);
+  cbv<Large_defaultedIn_defaultedIn_deleted> (Large_defaultedIn_defaultedIn_deleted_var);
+  cbv<Derived_defaultedIn_defaultedIn_deleted> (Derived_defaultedIn_defaultedIn_deleted_var);
+  cbv_container<Container_defaultedIn_defaultedIn_deleted> (Container_defaultedIn_defaultedIn_deleted_var);
+  cbv<Small_defaultedIn_defaultedOut_absent> (Small_defaultedIn_defaultedOut_absent_var);
+  cbv<Large_defaultedIn_defaultedOut_absent> (Large_defaultedIn_defaultedOut_absent_var);
+  cbv<Derived_defaultedIn_defaultedOut_absent> (Derived_defaultedIn_defaultedOut_absent_var);
+  cbv_container<Container_defaultedIn_defaultedOut_absent> (Container_defaultedIn_defaultedOut_absent_var);
+  cbv<Small_defaultedIn_defaultedOut_explicit> (Small_defaultedIn_defaultedOut_explicit_var);
+  cbv<Large_defaultedIn_defaultedOut_explicit> (Large_defaultedIn_defaultedOut_explicit_var);
+  cbv<Derived_defaultedIn_defaultedOut_explicit> (Derived_defaultedIn_defaultedOut_explicit_var);
+  cbv_container<Container_defaultedIn_defaultedOut_explicit> (Container_defaultedIn_defaultedOut_explicit_var);
+  cbv<Small_defaultedIn_defaultedOut_defaultedIn> (Small_defaultedIn_defaultedOut_defaultedIn_var);
+  cbv<Large_defaultedIn_defaultedOut_defaultedIn> (Large_defaultedIn_defaultedOut_defaultedIn_var);
+  cbv<Derived_defaultedIn_defaultedOut_defaultedIn> (Derived_defaultedIn_defaultedOut_defaultedIn_var);
+  cbv_container<Container_defaultedIn_defaultedOut_defaultedIn> (Container_defaultedIn_defaultedOut_defaultedIn_var);
+  cbv<Small_defaultedIn_defaultedOut_defaultedOut> (Small_defaultedIn_defaultedOut_defaultedOut_var);
+  cbv<Large_defaultedIn_defaultedOut_defaultedOut> (Large_defaultedIn_defaultedOut_defaultedOut_var);
+  cbv<Derived_defaultedIn_defaultedOut_defaultedOut> (Derived_defaultedIn_defaultedOut_defaultedOut_var);
+  cbv_container<Container_defaultedIn_defaultedOut_defaultedOut> (Container_defaultedIn_defaultedOut_defaultedOut_var);
+  cbv<Small_defaultedIn_defaultedOut_deleted> (Small_defaultedIn_defaultedOut_deleted_var);
+  cbv<Large_defaultedIn_defaultedOut_deleted> (Large_defaultedIn_defaultedOut_deleted_var);
+  cbv<Derived_defaultedIn_defaultedOut_deleted> (Derived_defaultedIn_defaultedOut_deleted_var);
+  cbv_container<Container_defaultedIn_defaultedOut_deleted> (Container_defaultedIn_defaultedOut_deleted_var);
+  cbv<Small_defaultedOut_absent_absent> (Small_defaultedOut_absent_absent_var);
+  cbv<Large_defaultedOut_absent_absent> (Large_defaultedOut_absent_absent_var);
+  cbv<Derived_defaultedOut_absent_absent> (Derived_defaultedOut_absent_absent_var);
+  cbv_container<Container_defaultedOut_absent_absent> (Container_defaultedOut_absent_absent_var);
+  cbv<Small_defaultedOut_absent_explicit> (Small_defaultedOut_absent_explicit_var);
+  cbv<Large_defaultedOut_absent_explicit> (Large_defaultedOut_absent_explicit_var);
+  cbv<Derived_defaultedOut_absent_explicit> (Derived_defaultedOut_absent_explicit_var);
+  cbv_container<Container_defaultedOut_absent_explicit> (Container_defaultedOut_absent_explicit_var);
+  cbv<Small_defaultedOut_absent_defaultedIn> (Small_defaultedOut_absent_defaultedIn_var);
+  cbv<Large_defaultedOut_absent_defaultedIn> (Large_defaultedOut_absent_defaultedIn_var);
+  cbv<Derived_defaultedOut_absent_defaultedIn> (Derived_defaultedOut_absent_defaultedIn_var);
+  cbv_container<Container_defaultedOut_absent_defaultedIn> (Container_defaultedOut_absent_defaultedIn_var);
+  cbv<Small_defaultedOut_absent_defaultedOut> (Small_defaultedOut_absent_defaultedOut_var);
+  cbv<Large_defaultedOut_absent_defaultedOut> (Large_defaultedOut_absent_defaultedOut_var);
+  cbv<Derived_defaultedOut_absent_defaultedOut> (Derived_defaultedOut_absent_defaultedOut_var);
+  cbv_container<Container_defaultedOut_absent_defaultedOut> (Container_defaultedOut_absent_defaultedOut_var);
+  cbv<Small_defaultedOut_absent_deleted> (Small_defaultedOut_absent_deleted_var);
+  cbv<Large_defaultedOut_absent_deleted> (Large_defaultedOut_absent_deleted_var);
+  cbv<Derived_defaultedOut_absent_deleted> (Derived_defaultedOut_absent_deleted_var);
+  cbv_container<Container_defaultedOut_absent_deleted> (Container_defaultedOut_absent_deleted_var);
+  cbv<Small_defaultedOut_explicit_absent> (Small_defaultedOut_explicit_absent_var);
+  cbv<Large_defaultedOut_explicit_absent> (Large_defaultedOut_explicit_absent_var);
+  cbv<Derived_defaultedOut_explicit_absent> (Derived_defaultedOut_explicit_absent_var);
+  cbv_container<Container_defaultedOut_explicit_absent> (Container_defaultedOut_explicit_absent_var);
+  cbv<Small_defaultedOut_explicit_explicit> (Small_defaultedOut_explicit_explicit_var);
+  cbv<Large_defaultedOut_explicit_explicit> (Large_defaultedOut_explicit_explicit_var);
+  cbv<Derived_defaultedOut_explicit_explicit> (Derived_defaultedOut_explicit_explicit_var);
+  cbv_container<Container_defaultedOut_explicit_explicit> (Container_defaultedOut_explicit_explicit_var);
+  cbv<Small_defaultedOut_explicit_defaultedIn> (Small_defaultedOut_explicit_defaultedIn_var);
+  cbv<Large_defaultedOut_explicit_defaultedIn> (Large_defaultedOut_explicit_defaultedIn_var);
+  cbv<Derived_defaultedOut_explicit_defaultedIn> (Derived_defaultedOut_explicit_defaultedIn_var);
+  cbv_container<Container_defaultedOut_explicit_defaultedIn> (Container_defaultedOut_explicit_defaultedIn_var);
+  cbv<Small_defaultedOut_explicit_defaultedOut> (Small_defaultedOut_explicit_defaultedOut_var);
+  cbv<Large_defaultedOut_explicit_defaultedOut> (Large_defaultedOut_explicit_defaultedOut_var);
+  cbv<Derived_defaultedOut_explicit_defaultedOut> (Derived_defaultedOut_explicit_defaultedOut_var);
+  cbv_container<Container_defaultedOut_explicit_defaultedOut> (Container_defaultedOut_explicit_defaultedOut_var);
+  cbv<Small_defaultedOut_explicit_deleted> (Small_defaultedOut_explicit_deleted_var);
+  cbv<Large_defaultedOut_explicit_deleted> (Large_defaultedOut_explicit_deleted_var);
+  cbv<Derived_defaultedOut_explicit_deleted> (Derived_defaultedOut_explicit_deleted_var);
+  cbv_container<Container_defaultedOut_explicit_deleted> (Container_defaultedOut_explicit_deleted_var);
+  cbv<Small_defaultedOut_defaultedIn_absent> (Small_defaultedOut_defaultedIn_absent_var);
+  cbv<Large_defaultedOut_defaultedIn_absent> (Large_defaultedOut_defaultedIn_absent_var);
+  cbv<Derived_defaultedOut_defaultedIn_absent> (Derived_defaultedOut_defaultedIn_absent_var);
+  cbv_container<Container_defaultedOut_defaultedIn_absent> (Container_defaultedOut_defaultedIn_absent_var);
+  cbv<Small_defaultedOut_defaultedIn_explicit> (Small_defaultedOut_defaultedIn_explicit_var);
+  cbv<Large_defaultedOut_defaultedIn_explicit> (Large_defaultedOut_defaultedIn_explicit_var);
+  cbv<Derived_defaultedOut_defaultedIn_explicit> (Derived_defaultedOut_defaultedIn_explicit_var);
+  cbv_container<Container_defaultedOut_defaultedIn_explicit> (Container_defaultedOut_defaultedIn_explicit_var);
+  cbv<Small_defaultedOut_defaultedIn_defaultedIn> (Small_defaultedOut_defaultedIn_defaultedIn_var);
+  cbv<Large_defaultedOut_defaultedIn_defaultedIn> (Large_defaultedOut_defaultedIn_defaultedIn_var);
+  cbv<Derived_defaultedOut_defaultedIn_defaultedIn> (Derived_defaultedOut_defaultedIn_defaultedIn_var);
+  cbv_container<Container_defaultedOut_defaultedIn_defaultedIn> (Container_defaultedOut_defaultedIn_defaultedIn_var);
+  cbv<Small_defaultedOut_defaultedIn_defaultedOut> (Small_defaultedOut_defaultedIn_defaultedOut_var);
+  cbv<Large_defaultedOut_defaultedIn_defaultedOut> (Large_defaultedOut_defaultedIn_defaultedOut_var);
+  cbv<Derived_defaultedOut_defaultedIn_defaultedOut> (Derived_defaultedOut_defaultedIn_defaultedOut_var);
+  cbv_container<Container_defaultedOut_defaultedIn_defaultedOut> (Container_defaultedOut_defaultedIn_defaultedOut_var);
+  cbv<Small_defaultedOut_defaultedIn_deleted> (Small_defaultedOut_defaultedIn_deleted_var);
+  cbv<Large_defaultedOut_defaultedIn_deleted> (Large_defaultedOut_defaultedIn_deleted_var);
+  cbv<Derived_defaultedOut_defaultedIn_deleted> (Derived_defaultedOut_defaultedIn_deleted_var);
+  cbv_container<Container_defaultedOut_defaultedIn_deleted> (Container_defaultedOut_defaultedIn_deleted_var);
+  cbv<Small_defaultedOut_defaultedOut_absent> (Small_defaultedOut_defaultedOut_absent_var);
+  cbv<Large_defaultedOut_defaultedOut_absent> (Large_defaultedOut_defaultedOut_absent_var);
+  cbv<Derived_defaultedOut_defaultedOut_absent> (Derived_defaultedOut_defaultedOut_absent_var);
+  cbv_container<Container_defaultedOut_defaultedOut_absent> (Container_defaultedOut_defaultedOut_absent_var);
+  cbv<Small_defaultedOut_defaultedOut_explicit> (Small_defaultedOut_defaultedOut_explicit_var);
+  cbv<Large_defaultedOut_defaultedOut_explicit> (Large_defaultedOut_defaultedOut_explicit_var);
+  cbv<Derived_defaultedOut_defaultedOut_explicit> (Derived_defaultedOut_defaultedOut_explicit_var);
+  cbv_container<Container_defaultedOut_defaultedOut_explicit> (Container_defaultedOut_defaultedOut_explicit_var);
+  cbv<Small_defaultedOut_defaultedOut_defaultedIn> (Small_defaultedOut_defaultedOut_defaultedIn_var);
+  cbv<Large_defaultedOut_defaultedOut_defaultedIn> (Large_defaultedOut_defaultedOut_defaultedIn_var);
+  cbv<Derived_defaultedOut_defaultedOut_defaultedIn> (Derived_defaultedOut_defaultedOut_defaultedIn_var);
+  cbv_container<Container_defaultedOut_defaultedOut_defaultedIn> (Container_defaultedOut_defaultedOut_defaultedIn_var);
+  cbv<Small_defaultedOut_defaultedOut_defaultedOut> (Small_defaultedOut_defaultedOut_defaultedOut_var);
+  cbv<Large_defaultedOut_defaultedOut_defaultedOut> (Large_defaultedOut_defaultedOut_defaultedOut_var);
+  cbv<Derived_defaultedOut_defaultedOut_defaultedOut> (Derived_defaultedOut_defaultedOut_defaultedOut_var);
+  cbv_container<Container_defaultedOut_defaultedOut_defaultedOut> (Container_defaultedOut_defaultedOut_defaultedOut_var);
+  cbv<Small_defaultedOut_defaultedOut_deleted> (Small_defaultedOut_defaultedOut_deleted_var);
+  cbv<Large_defaultedOut_defaultedOut_deleted> (Large_defaultedOut_defaultedOut_deleted_var);
+  cbv<Derived_defaultedOut_defaultedOut_deleted> (Derived_defaultedOut_defaultedOut_deleted_var);
+  cbv_container<Container_defaultedOut_defaultedOut_deleted> (Container_defaultedOut_defaultedOut_deleted_var);
+
+
+  /* stop here */
+
+  return 0;
 }
diff --git a/gdb/testsuite/gdb.cp/pass-by-ref.exp b/gdb/testsuite/gdb.cp/pass-by-ref.exp
index 94dd3455ee4..8051c5c26b1 100644
--- a/gdb/testsuite/gdb.cp/pass-by-ref.exp
+++ b/gdb/testsuite/gdb.cp/pass-by-ref.exp
@@ -14,20 +14,418 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 # Check that GDB can call C++ functions whose parameters have
-# object type, but are passed by reference.
+# object type, and are either passed by value or implicitly by reference.
+#
+# Suppose F is a function that has a call-by-value parameter whose
+# type is class C.  When calling F with an argument A, a copy of A should
+# be created and passed to F.  If C is a trivially-copyable type, A can
+# be copied by a straightforward memory copy.  However, roughly speaking,
+# if C has a user-defined copy constructor and/or a user-defined
+# destructor, the copy ctor should be used to initialize the copy of A
+# before calling F, and a reference to that copy is passed to F.  After
+# the function returns, the destructor should be called to destruct the
+# copy.  In this case, C is said to be a 'pass-by-reference' type.
+# Determining whether C is pass-by-ref depends on
+# how the copy ctor, destructor, and the move ctor of C are defined.
+# First of all, C is not copy constructible if its copy constructor is
+# explicitly or implicitly deleted.  In this case, it would be illegal
+# to pass values of type C to a function.  C is pass-by-value, if all of
+# its copy ctor, dtor, and move ctor are trivially defined.
+# Otherwise, it is pass-by-ref.
+#
+# To cover the many possible combinations, this test generates classes
+# that contain three special functions:
+#   (1) a copy constructor,
+#   (2) a destructor, and
+#   (3) a move constructor.
+# A special function is in one of the following states:
+#  * explicit: The function is explicitly defined by the user.
+#  * defaultedIn: The function is defaulted inside the class decl,
+#      using the 'default' keyword.
+#  * defaultedOut: The function is declared inside the class decl,
+#      and defaulted outside using the 'default' keyword.
+#  * deleted: The function is explicitly deleted by the user,
+#      using the 'delete' keyword.
+#  * absent: The function is not declared by the user (i.e. it does not
+#      exist in the source.  The compiler generates (or deletes) the
+#      definition in this case.
+#
+# The C++ ABI decides if a class is pass-by-value or pass-by-ref
+# (i.e.  trivially copyable or not) first at the language level, based
+# on the state of the special functions.  Then, at the target level, a
+# class may be determined to be pass-by-ref because of its size
+# (e.g.  if it is too large to fit on registers).  For this reason, this
+# test generates both a small and a large version for the same
+# combination of special function states.
+#
+# A class is not trivially-copyable if a base class or a field is not
+# trivially-copyable, even though the class definition itself seems
+# trivial.  To test these cases, we also generate derived classes and
+# container classes.
+#
+# The companion test file pass-by-ref-2.exp also contains
+# manually-written cases.
+
+#
+# Flag to control whether to re-generate the source file
+#
+set GENERATE_SOURCE false
 
-if { [skip_cplus_tests] } { continue }
+if {[skip_cplus_tests]} {
+    untested "c++ test skipped"
+    continue
+}
 
 standard_testfile .cc
 
-if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
+# Some constant values used when generating the source
+
+set SMALL    2
+set LARGE    150
+set ORIGINAL 2
+set CUSTOM   3
+set ADDED    4
+set TRACE    5
+
+
+# Return 1 if the class whose special function states are STATES
+# is copyable.  Otherwise return 0.
+
+proc is_copy_constructible { states } {
+    set cctor [lindex $states 0]
+    set dtor  [lindex $states 1]
+    set mctor [lindex $states 2]
+
+    if {$cctor == "deleted" || ($cctor == "absent" && $mctor != "absent")} {
+	return 0
+    }
+    return 1
+}
+
+# Generate a declaration and an out-of-class definition for a function
+# with the provided signature.  The STATE should be one of the following:
+# - explicit, defaultedIn, defaultedOut, deleted, absent
+
+proc generate_member_function { classname signature length state } {
+    set declaration ""
+    set definition ""
+
+    global CUSTOM
+    global TRACE
+
+    switch $state {
+	explicit {
+	    set declaration "$signature;\n"
+	    set definition "$classname\:\:$signature
+                            {
+                              data\[0\] = $CUSTOM;
+                              data\[[expr $length - 1]\] = $CUSTOM;
+                              tracer = $TRACE;
+                            }\n"
+	}
+	defaultedIn {
+	    set declaration "$signature = default;\n"
+	}
+	defaultedOut {
+	    set declaration "$signature;\n"
+	    set definition "$classname\:\:$signature = default;\n"
+	}
+	deleted {
+	    set declaration "$signature = delete;\n"
+	}
+	default {
+	    # function is not user-defined in this case
+	}
+    }
+
+    return [list $declaration $definition]
+}
+
+# Generate a C++ class with the given CLASSNAME and LENGTH-many
+# integer elements.  The STATES is an array of 3 items
+# containing the desired state of the special functions
+# in this order:
+# copy constructor, destructor, move constructor
+
+proc generate_class { classname length states } {
+    set declarations ""
+    set definitions ""
+    set classname "${classname}_[join $states _]"
+
+    for {set i 0} {$i < [llength $states]} {incr i} {
+	set sig ""
+	switch $i {
+	    0 {set sig "$classname (const $classname \&rhs)"}
+	    1 {set sig "\~$classname (void)"}
+	    2 {set sig "$classname ($classname \&\&rhs)"}
+	}
+
+	set state [lindex $states $i]
+	set code [generate_member_function $classname $sig $length $state]
+	append declarations [lindex $code 0]
+	append definitions [lindex $code 1]
+    }
+
+    global ORIGINAL
+
+    return "
+    /*** C++ class $classname ***/
+    class ${classname} {
+    public:
+        $classname (void);
+        $declarations
+
+        int data\[$length\];
+    };
+
+    $classname\:\:$classname (void)
+    {
+        data\[0\] = $ORIGINAL;
+        data\[[expr $length - 1]\] = $ORIGINAL;
+    }
+
+    $definitions
+
+    $classname ${classname}_var; /* global var */
+
+    template int cbv<$classname> ($classname arg);"
+}
+
+# Generate a small C++ class
+
+proc generate_small_class { states } {
+    global SMALL
+    return [generate_class Small $SMALL $states];
+}
+
+# Generate a large C++ class
+
+proc generate_large_class { states } {
+    global LARGE
+    return [generate_class Large $LARGE $states];
+}
+
+# Generate a class that derives from a small class
+
+proc generate_derived_class { states } {
+    set base "Small_[join $states _]"
+    set classname "Derived_[join $states _]"
+
+    return "
+    /*** Class derived from $base ***/
+    class $classname : public $base {
+    public:
+    };
+
+    $classname ${classname}_var; /* global var */
+
+    template int cbv<$classname> ($classname arg);"
+}
+
+# Generate a class that contains a small class item
+
+proc generate_container_class { states } {
+    set contained "Small_[join $states _]"
+    set classname "Container_[join $states _]"
+
+    return "
+    /*** Class that contains $contained ***/
+    class $classname {
+    public:
+        $contained item;
+    };
+
+    $classname ${classname}_var; /* global var */
+
+    template int cbv_container<$classname> ($classname arg);"
+}
+
+# Generate useful statements that use a class in the debugee program
+
+proc generate_stmts { classprefix states {cbvfun "cbv"}} {
+    set classname "${classprefix}_[join $states _]"
+
+    # Having an explicit call to the cbv function in the debugee program
+    # ensures that the compiler will emit necessary function in the binary.
+    if {[is_copy_constructible $states]} {
+	set cbvcall "$cbvfun<$classname> (${classname}_var);\n"
+    } else {
+	set cbvcall ""
+    }
+
+    return "$cbvcall"
+}
+
+# Generate the complete debugee program
+
+proc generate_program { classes stmts } {
+    set copyright "/* This testcase is part of GDB, the GNU debugger.
+
+    Copyright 2007-2019 Free Software Foundation, Inc.
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */"
+
+    global ADDED
+
+    return "$copyright
+
+    /*** THIS FILE IS GENERATED BY THE TEST.  ***/
+    /* If you regenerate, auto-indent and delete-trailing-whitespace
+       before committing.  */
+
+    static int tracer = 0;
+
+    /* The call-by-value function.  */
+    template <class T>
+    int
+    cbv (T arg)
+    {
+      arg.data\[0\] += $ADDED; // intentionally modify the arg
+      return arg.data\[0\];
+    }
+
+    template <class T>
+    int
+    cbv_container (T arg)
+    {
+      arg.item.data\[0\] += $ADDED;  // intentionally modify
+      return arg.item.data\[0\];
+    }
+
+    $classes
+
+    int
+    main (void)
+    {
+      $stmts
+
+      /* stop here */
+
+      return 0;
+    }"
+}
+
+# Compute all the combinations of special function states.
+# We do not contain the 'deleted' state for the destructor,
+# because it is illegal to have stack-allocated objects
+# whose destructor have been deleted.  This case is covered
+# in pass-by-ref-2 via heap-allocated objects.
+
+set options_nodelete [list absent explicit defaultedIn defaultedOut]
+set options [concat $options_nodelete {deleted}]
+set all_combinations {}
+
+foreach cctor $options {
+    foreach dtor $options_nodelete {
+	foreach mctor $options {
+	    lappend all_combinations [list $cctor $dtor $mctor]
+	}
+    }
+}
+
+if {$GENERATE_SOURCE} {
+    # Generate the classes and overwrite srcfile
+
+    set classes ""
+    set stmts ""
+
+    foreach state $all_combinations {
+	append classes [generate_small_class $state]
+	append stmts [generate_stmts "Small" $state]
+
+	append classes [generate_large_class $state]
+	append stmts [generate_stmts "Large" $state]
+
+	append classes [generate_derived_class $state]
+	append stmts [generate_stmts "Derived" $state]
+
+	append classes [generate_container_class $state]
+	append stmts [generate_stmts "Container" $state "cbv_container"]
+    }
+
+    # Generate the program code and compile
+    set program [generate_program $classes $stmts]
+    set testfolder [file dirname $testfile]
+    gdb_produce_source ${srcdir}/${subdir}/$srcfile $program
+}
+
+set options {debug c++ additional_flags=-std=c++11}
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile $options]} {
     return -1
 }
 
-if ![runto_main] then {
+if {![runto_main]} {
+    untested "failed to run to main"
     return -1
 }
 
-gdb_test "print foo (global_obj)" " = 3" "call function in obj"
-gdb_test "print blap (global_derived)" " = 3" "call function in derived"
-gdb_test "print blip (global_container)" " = 3" "call function in container"
+set bp_location [gdb_get_line_number "stop here"]
+gdb_breakpoint $bp_location
+gdb_continue_to_breakpoint "end of main" ".*return .*;"
+
+# Do the checks for a given class whose name is prefixed with PREFIX,
+# and whose special functions have the states given in STATES.
+# The name of the call-by-value function and the expression to access
+# the data field can be specified explicitly if the default values
+# do not work.
+
+proc test_for_class { prefix states cbvfun data_field length} {
+    set name "${prefix}_[join $states _]"
+
+    set cctor [lindex $states 0]
+    set dtor  [lindex $states 1]
+    set mctor [lindex $states 2]
+
+    global ORIGINAL
+    global CUSTOM
+    global ADDED
+    global TRACE
+
+    with_test_prefix $name {
+	if {[is_copy_constructible $states]} {
+	    set expected [expr {$ORIGINAL + $ADDED}]
+	    if {$cctor == "explicit"} {
+		set expected [expr {$CUSTOM + $ADDED}]
+	    }
+	    if {$dtor == "explicit"} {
+		gdb_test "print tracer = 0" " = 0" "reset the tracer"
+	    }
+	    gdb_test "print ${cbvfun}<$name> (${name}_var)" " = $expected" \
+		"call '$cbvfun'"
+	    gdb_test "print ${name}_var.${data_field}\[0\]" " = $ORIGINAL" \
+		"cbv argument should not change (item 0)"
+	    if {$length > 1} {
+		set last_index [expr $length - 1]
+		gdb_test "print ${name}_var.${data_field}\[$last_index\]" \
+		    " = $ORIGINAL" \
+		    "cbv argument should not change (item $last_index)"
+	    }
+	    if {$dtor == "explicit"} {
+		gdb_test "print tracer" " = $TRACE" \
+		    "destructor should be called"
+	    }
+	} else {
+	    gdb_test "print ${cbvfun}<$name> (${name}_var)" \
+		".* cannot be evaluated .* '${name}' is not copy constructible" \
+		"calling '$cbvfun' should be refused"
+	}
+    }
+}
+
+foreach state $all_combinations {
+    test_for_class "Small"     $state "cbv"           "data"      $SMALL
+    test_for_class "Large"     $state "cbv"           "data"      $LARGE
+    test_for_class "Derived"   $state "cbv"           "data"      1
+    test_for_class "Container" $state "cbv_container" "item.data" 1
+}
-- 
2.17.1

[PATCH v2 4/8] infcall: refactor 'call_function_by_hand_dummy'

[Tankut Baris Aktemur]

Extract out the code region that reserves stack space to a separate
function.

Fix the comment of 'call_function_by_hand_dummy' to remove reference
to the NARGS argument that was removed in this commit:
e71585ffe2e Use gdb:array_view in call_function_by_hand & friends

gdb/ChangeLog:

2019-MM-DD  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>

	* infcall.c (call_function_by_hand_dummy): Refactor.
	(reserve_stack_space): New.

2019-06-24  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>
---
 gdb/infcall.c | 64 +++++++++++++++++++++++++++++++--------------------
 1 file changed, 39 insertions(+), 25 deletions(-)

diff --git a/gdb/infcall.c b/gdb/infcall.c
index 9b833643dcc..ea96f887c8b 100644
--- a/gdb/infcall.c
+++ b/gdb/infcall.c
@@ -670,6 +670,42 @@ run_inferior_call (struct call_thread_fsm *sm,
   return caught_error;
 }
 
+/* Reserve space on the stack for a value of the given type.
+   Return the address of the allocated space.
+   Make certain that the value is correctly aligned.
+   The SP argument is modified.  */
+
+static CORE_ADDR
+reserve_stack_space (const type *values_type, CORE_ADDR &sp)
+{
+  struct frame_info *frame = get_current_frame ();
+  struct gdbarch *gdbarch = get_frame_arch (frame);
+  CORE_ADDR addr = 0;
+
+  if (gdbarch_inner_than (gdbarch, 1, 2))
+    {
+      /* Stack grows downward.  Align STRUCT_ADDR and SP after
+	 making space.  */
+      sp -= TYPE_LENGTH (values_type);
+      if (gdbarch_frame_align_p (gdbarch))
+	sp = gdbarch_frame_align (gdbarch, sp);
+      addr = sp;
+    }
+  else
+    {
+      /* Stack grows upward.  Align the frame, allocate space, and
+	 then again, re-align the frame???  */
+      if (gdbarch_frame_align_p (gdbarch))
+	sp = gdbarch_frame_align (gdbarch, sp);
+      addr = sp;
+      sp += TYPE_LENGTH (values_type);
+      if (gdbarch_frame_align_p (gdbarch))
+	sp = gdbarch_frame_align (gdbarch, sp);
+    }
+
+  return addr;
+}
+
 /* See infcall.h.  */
 
 struct value *
@@ -691,7 +727,7 @@ call_function_by_hand (struct value *function,
    making dummy frames be different from normal frames, consider that.  */
 
 /* Perform a function call in the inferior.
-   ARGS is a vector of values of arguments (NARGS of them).
+   ARGS is a vector of values of arguments.
    FUNCTION is a value, the function to be called.
    Returns a value representing what the function returned.
    May fail to return, if a breakpoint or signal is hit
@@ -991,8 +1027,7 @@ call_function_by_hand_dummy (struct value *function,
     }
 
   /* Reserve space for the return structure to be written on the
-     stack, if necessary.  Make certain that the value is correctly
-     aligned.
+     stack, if necessary.
 
      While evaluating expressions, we reserve space on the stack for
      return values of class type even if the language ABI and the target
@@ -1007,28 +1042,7 @@ call_function_by_hand_dummy (struct value *function,
 
   if (return_method != return_method_normal
       || (stack_temporaries && class_or_union_p (values_type)))
-    {
-      if (gdbarch_inner_than (gdbarch, 1, 2))
-	{
-	  /* Stack grows downward.  Align STRUCT_ADDR and SP after
-             making space for the return value.  */
-	  sp -= TYPE_LENGTH (values_type);
-	  if (gdbarch_frame_align_p (gdbarch))
-	    sp = gdbarch_frame_align (gdbarch, sp);
-	  struct_addr = sp;
-	}
-      else
-	{
-	  /* Stack grows upward.  Align the frame, allocate space, and
-             then again, re-align the frame???  */
-	  if (gdbarch_frame_align_p (gdbarch))
-	    sp = gdbarch_frame_align (gdbarch, sp);
-	  struct_addr = sp;
-	  sp += TYPE_LENGTH (values_type);
-	  if (gdbarch_frame_align_p (gdbarch))
-	    sp = gdbarch_frame_align (gdbarch, sp);
-	}
-    }
+    struct_addr = reserve_stack_space (values_type, sp);
 
   std::vector<struct value *> new_args;
   if (return_method == return_method_hidden_param)
-- 
2.17.1

[PATCH v2 0/8] Fix inferior call for C++ pass-by-reference arguments

[Tankut Baris Aktemur]

Hi All,

This is a set of patches to fix GDB's conformance to C++ ABI when
invoking functions that have call-by-value arguments of aggregate
types that should be implicitly passed by reference.

The v1 of the series is available at
https://sourceware.org/ml/gdb-patches/2019-04/msg00461.html

Changes since v1:
* Patches 1-3 have been revised according to the reviews
  (thanks to Andrew Burgess).
* The patches have been rebased to the current master.

Regards,
-Baris

Tankut Baris Aktemur (8):
  gdb: recognize new DWARF attributes: defaulted, deleted, calling conv.
  infcall, c++: allow more info to be computed for pass-by-reference
    values
  infcall, c++: collect more pass-by-reference information
  infcall: refactor 'call_function_by_hand_dummy'
  infcall: move assertions in 'call_function_by_hand_dummy' to an
    earlier spot
  infcall: remove unused parameter in 'value_arg_coerce'
  infcall: handle pass-by-reference arguments appropriately
  testsuite, cp: increase the coverage of testing pass-by-ref arguments

 gdb/arch-utils.c                       |    2 +-
 gdb/cp-abi.c                           |    6 +-
 gdb/cp-abi.h                           |   10 +-
 gdb/dwarf2read.c                       |   20 +
 gdb/gdbtypes.c                         |    7 +
 gdb/gdbtypes.h                         |   21 +-
 gdb/gnu-v3-abi.c                       |  284 +-
 gdb/infcall.c                          |  213 +-
 gdb/language.c                         |   19 +-
 gdb/language.h                         |   70 +-
 gdb/testsuite/gdb.cp/pass-by-ref-2.cc  |  179 +
 gdb/testsuite/gdb.cp/pass-by-ref-2.exp |   85 +
 gdb/testsuite/gdb.cp/pass-by-ref.cc    | 7368 +++++++++++++++++++++++-
 gdb/testsuite/gdb.cp/pass-by-ref.exp   |  412 +-
 gdb/tic6x-tdep.c                       |    2 +-
 15 files changed, 8538 insertions(+), 160 deletions(-)
 create mode 100644 gdb/testsuite/gdb.cp/pass-by-ref-2.cc
 create mode 100644 gdb/testsuite/gdb.cp/pass-by-ref-2.exp

-- 
2.17.1

[PATCH v2 1/8] gdb: recognize new DWARF attributes: defaulted, deleted, calling conv.

[Tankut Baris Aktemur]

Extend GDB's internal representation of types to include the
DW_AT_calling_convention, DW_AT_defaulted, and DW_AT_deleted attributes
that were introduced in DWARF5.

gdb/ChangeLog:

2019-MM-DD  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>

	* dwarf2read.c (dwarf2_add_member_fn): Read the DW_AT_defaulted
	and DW_AT_deleted attributes of a function.
	(read_structure_type): Read the	DW_AT_calling_convention attribute
	of a type.
	* gdbtypes.h (struct fn_field)<defaulted>: New field to store the
	DW_AT_defaulted attribute.
	(struct fn_field)<is_deleted>: New field to store the DW_AT_deleted
	attribute.
	(struct cplus_struct_type)<calling_convention>: New field to store
	the DW_AT_calling_convention attribute.
	(TYPE_FN_FIELD_DEFAULTED): New macro.
	(TYPE_FN_FIELD_DELETED): New macro.
	(TYPE_CPLUS_CALLING_CONVENTION): New macro.
	* gdbtypes.c:  (dump_fn_fieldlists): Update for the changes made
	to the .h file.
	(print_cplus_stuff): Likewise.

2019-06-24  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>
---
 gdb/dwarf2read.c | 20 ++++++++++++++++++++
 gdb/gdbtypes.c   |  7 +++++++
 gdb/gdbtypes.h   | 21 ++++++++++++++++++++-
 3 files changed, 47 insertions(+), 1 deletion(-)

diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c
index 85f2b1dfc47..125af083a7a 100644
--- a/gdb/dwarf2read.c
+++ b/gdb/dwarf2read.c
@@ -15467,6 +15467,16 @@ dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
   if (attr && DW_UNSND (attr) != 0)
     fnp->is_artificial = 1;
 
+  /* Check for defaulted methods.  */
+  attr = dwarf2_attr (die, DW_AT_defaulted, cu);
+  if (attr)
+    fnp->defaulted = DW_UNSND (attr);
+
+  /* Check for deleted methods.  */
+  attr = dwarf2_attr (die, DW_AT_deleted, cu);
+  if (attr && DW_UNSND (attr) != 0)
+    fnp->is_deleted = 1;
+
   fnp->is_constructor = dwarf2_is_constructor (die, cu);
 
   /* Get index in virtual function table if it is a virtual member
@@ -15787,6 +15797,16 @@ read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
   if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
     TYPE_DECLARED_CLASS (type) = 1;
 
+  /* Store the calling convention in the type if it's available in
+     the die.  Otherwise the calling convention remains set to
+     the default value DW_CC_normal.  */
+  attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
+  if (attr)
+    {
+      ALLOCATE_CPLUS_STRUCT_TYPE (type);
+      TYPE_CPLUS_CALLING_CONVENTION (type) = DW_UNSND (attr);
+    }
+
   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
   if (attr)
     {
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index e329adc368e..c05c10079e1 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -4389,6 +4389,10 @@ dump_fn_fieldlists (struct type *type, int spaces)
 			    TYPE_FN_FIELD_PROTECTED (f, overload_idx));
 	  printfi_filtered (spaces + 8, "is_stub %d\n",
 			    TYPE_FN_FIELD_STUB (f, overload_idx));
+	  printfi_filtered (spaces + 8, "defaulted %d\n",
+			    TYPE_FN_FIELD_DEFAULTED (f, overload_idx));
+	  printfi_filtered (spaces + 8, "is_deleted %d\n",
+			    TYPE_FN_FIELD_DELETED (f, overload_idx));
 	  printfi_filtered (spaces + 8, "voffset %u\n",
 			    TYPE_FN_FIELD_VOFFSET (f, overload_idx));
 	}
@@ -4452,6 +4456,9 @@ print_cplus_stuff (struct type *type, int spaces)
     {
       dump_fn_fieldlists (type, spaces);
     }
+
+  printfi_filtered (spaces, "calling_convention %d\n",
+		    TYPE_CPLUS_CALLING_CONVENTION (type));
 }
 
 /* Print the contents of the TYPE's type_specific union, assuming that
diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index 49653ffcaf7..a5b57898244 100644
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -919,6 +919,11 @@ struct fn_field
 
   struct type *fcontext;
 
+  /* * DW_AT_defaulted attribute for this function; the value is one
+     of the DW_DEFAULTED enum dwarf_defaulted_attribute constants.  */
+
+  unsigned int defaulted;
+
   /* Attributes.  */
 
   unsigned int is_const:1;
@@ -936,9 +941,13 @@ struct fn_field
 
   unsigned int is_constructor : 1;
 
+  /* * True if this function is deleted, false otherwise.  */
+
+  unsigned int is_deleted : 1;
+
   /* * Unused.  */
 
-  unsigned int dummy:9;
+  unsigned int dummy:8;
 
   /* * Index into that baseclass's virtual function table, minus 2;
      else if static: VOFFSET_STATIC; else: 0.  */
@@ -1080,6 +1089,12 @@ struct cplus_struct_type
        classes.  */
 
     struct symbol **template_arguments;
+
+    /* * The calling convention for this type, fetched from the
+       DW_AT_calling_convention attribute.  The value is one of the
+       DW_CC enum dwarf_calling_convention constants.  */
+
+    unsigned calling_convention : 8;
   };
 
 /* * Struct used to store conversion rankings.  */
@@ -1410,6 +1425,8 @@ extern void set_type_vptr_basetype (struct type *, struct type *);
     ? (struct cplus_struct_type*)&cplus_struct_default \
     : TYPE_RAW_CPLUS_SPECIFIC(thistype))
 #define TYPE_RAW_CPLUS_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff
+#define TYPE_CPLUS_CALLING_CONVENTION(thistype) \
+  TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff->calling_convention
 #define TYPE_FLOATFORMAT(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.floatformat
 #define TYPE_GNAT_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.gnat_stuff
 #define TYPE_DESCRIPTIVE_TYPE(thistype) TYPE_GNAT_SPECIFIC(thistype)->descriptive_type
@@ -1526,6 +1543,8 @@ extern void set_type_vptr_basetype (struct type *, struct type *);
 #define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2)
 #define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1)
 #define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC)
+#define TYPE_FN_FIELD_DEFAULTED(thisfn, n) ((thisfn)[n].defaulted)
+#define TYPE_FN_FIELD_DELETED(thisfn, n) ((thisfn)[n].is_deleted)
 
 /* Accessors for typedefs defined by a class.  */
 #define TYPE_TYPEDEF_FIELD_ARRAY(thistype) \
-- 
2.17.1

[PATCH v2 2/8] infcall, c++: allow more info to be computed for pass-by-reference values

[Tankut Baris Aktemur]

In C++, call-by-value arguments that cannot be trivially copied are
implicitly passed by reference.  When making an infcall, GDB needs to
find out if an argument is pass-by-reference or not, so that the correct
semantics can be followed.  This patch enriches the information computed
by the language ops for pass-by-reference arguments.  Instead of a plain
binary result, the computed information now includes whether the
argument is
  - copy constructible
  - destructible
  - trivially copyable
  - trivially copy constructible
  - trivially destructible
and also
  - the full name of the copy constructor
  - the full name of the destructor
This information is stored in a struct named 'language_pass_by_ref_info'.

This patch paves the way for GDB's infcall mechanism to call the copy
ctor and the destructor of a pass-by-ref argument appropriately.

gdb/ChangeLog:

2019-MM-DD  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>

	* language.h (struct language_pass_by_ref_info): New struct.
	(struct language_defn)<la_pass_by_reference>: Change the signature
	to return a language_pass_by_ref_info instead of an int.
	(language_pass_by_reference): Ditto.
	(default_pass_by_reference): Ditto.
	Adjust the users listed below.
	* arch-utils.c (default_return_in_first_hidden_param_p):
	Update.
	* cp-abi.c (cp_pass_by_reference): Update.
	* cp-abi.h (struct cp_abi_ops)<pass_by_reference>: Update.
	* gnu-v3-abi.c (gnuv3_pass_by_reference): Update.
	* infcall.c (call_function_by_hand_dummy): Update.
	* language.c (language_pass_by_reference): Update.
	(default_pass_by_reference): Update.
	* tic6x-tdep.c (tic6x_return_value): Update.

2019-06-24  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>
---
 gdb/arch-utils.c |  2 +-
 gdb/cp-abi.c     |  6 +++--
 gdb/cp-abi.h     | 10 ++++---
 gdb/gnu-v3-abi.c | 49 ++++++++++++++++++++++++---------
 gdb/infcall.c    |  3 ++-
 gdb/language.c   | 19 +++++++------
 gdb/language.h   | 70 +++++++++++++++++++++++++++++++++++++++++-------
 gdb/tic6x-tdep.c |  2 +-
 8 files changed, 121 insertions(+), 40 deletions(-)

diff --git a/gdb/arch-utils.c b/gdb/arch-utils.c
index 43f5834b383..5ccabde45e3 100644
--- a/gdb/arch-utils.c
+++ b/gdb/arch-utils.c
@@ -858,7 +858,7 @@ default_return_in_first_hidden_param_p (struct gdbarch *gdbarch,
   /* Usually, the return value's address is stored the in the "first hidden"
      parameter if the return value should be passed by reference, as
      specified in ABI.  */
-  return language_pass_by_reference (type);
+  return !(language_pass_by_reference (type).trivially_copyable);
 }
 
 int default_insn_is_call (struct gdbarch *gdbarch, CORE_ADDR addr)
diff --git a/gdb/cp-abi.c b/gdb/cp-abi.c
index bbb74d42638..6503b4c160b 100644
--- a/gdb/cp-abi.c
+++ b/gdb/cp-abi.c
@@ -220,11 +220,13 @@ cplus_typename_from_type_info (struct value *value)
   return (*current_cp_abi.get_typename_from_type_info) (value);
 }
 
-int
+/* See cp-abi.h.  */
+
+struct language_pass_by_ref_info
 cp_pass_by_reference (struct type *type)
 {
   if ((current_cp_abi.pass_by_reference) == NULL)
-    return 0;
+    return default_pass_by_reference (type);
   return (*current_cp_abi.pass_by_reference) (type);
 }
 
diff --git a/gdb/cp-abi.h b/gdb/cp-abi.h
index 3cbf19cd511..cc77e0b0632 100644
--- a/gdb/cp-abi.h
+++ b/gdb/cp-abi.h
@@ -207,9 +207,11 @@ extern std::string cplus_typename_from_type_info (struct value *value);
 CORE_ADDR cplus_skip_trampoline (struct frame_info *frame,
 				 CORE_ADDR stop_pc);
 
-/* Return non-zero if an argument of type TYPE should be passed by
-   reference instead of value.  */
-extern int cp_pass_by_reference (struct type *type);
+/* Return a struct that provides pass-by-reference information
+   about the given TYPE.  */
+
+extern struct language_pass_by_ref_info cp_pass_by_reference
+  (struct type *type);
 
 struct cp_abi_ops
 {
@@ -246,7 +248,7 @@ struct cp_abi_ops
   struct type *(*get_type_from_type_info) (struct value *value);
   std::string (*get_typename_from_type_info) (struct value *value);
   CORE_ADDR (*skip_trampoline) (struct frame_info *, CORE_ADDR);
-  int (*pass_by_reference) (struct type *type);
+  struct language_pass_by_ref_info (*pass_by_reference) (struct type *type);
 };
 
 
diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c
index 6407c9beb82..69cd56859cb 100644
--- a/gdb/gnu-v3-abi.c
+++ b/gdb/gnu-v3-abi.c
@@ -1228,7 +1228,7 @@ gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
   return real_stop_pc;
 }
 
-/* Return nonzero if a type should be passed by reference.
+/* Return pass-by-reference information for the given TYPE.
 
    The rule in the v3 ABI document comes from section 3.1.1.  If the
    type has a non-trivial copy constructor or destructor, then the
@@ -1246,22 +1246,33 @@ gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
 
    We don't do anything with the constructors or destructors,
    but we have to get the argument passing right anyway.  */
-static int
+
+static struct language_pass_by_ref_info
 gnuv3_pass_by_reference (struct type *type)
 {
   int fieldnum, fieldelem;
 
   type = check_typedef (type);
 
+  /* Start with the default values.  */
+  struct language_pass_by_ref_info info
+    = default_pass_by_reference (type);
+
+  /* FIXME: Currently, this implementation only fills in the
+     'trivially-copyable' field to perserve GDB's existing behavior.  */
+
   /* We're only interested in things that can have methods.  */
   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
       && TYPE_CODE (type) != TYPE_CODE_UNION)
-    return 0;
+    return info;
 
   /* A dynamic class has a non-trivial copy constructor.
      See c++98 section 12.8 Copying class objects [class.copy].  */
   if (gnuv3_dynamic_class (type))
-    return 1;
+    {
+      info.trivially_copyable = false;
+      return info;
+    }
 
   for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
     for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
@@ -1278,7 +1289,10 @@ gnuv3_pass_by_reference (struct type *type)
 
 	/* If we've found a destructor, we must pass this by reference.  */
 	if (name[0] == '~')
-	  return 1;
+	  {
+	    info.trivially_copyable = false;
+	    return info;
+	  }
 
 	/* If the mangled name of this method doesn't indicate that it
 	   is a constructor, we're not interested.
@@ -1300,11 +1314,13 @@ gnuv3_pass_by_reference (struct type *type)
 
 	    if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
 	      {
-		struct type *arg_target_type;
-
-	        arg_target_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
+		struct type *arg_target_type
+		  = check_typedef (TYPE_TARGET_TYPE (arg_type));
 		if (class_types_same_p (arg_target_type, type))
-		  return 1;
+		  {
+		    info.trivially_copyable = false;
+		    return info;
+		  }
 	      }
 	  }
       }
@@ -1317,11 +1333,18 @@ gnuv3_pass_by_reference (struct type *type)
      about recursive loops here, since we are only looking at members
      of complete class type.  Also ignore any static members.  */
   for (fieldnum = 0; fieldnum < TYPE_NFIELDS (type); fieldnum++)
-    if (! field_is_static (&TYPE_FIELD (type, fieldnum))
-        && gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type, fieldnum)))
-      return 1;
+    if (!field_is_static (&TYPE_FIELD (type, fieldnum)))
+      {
+	struct language_pass_by_ref_info field_info
+	  = gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type, fieldnum));
+	if (!field_info.trivially_copyable)
+	  {
+	    info.trivially_copyable = false;
+	    return info;
+	  }
+      }
 
-  return 0;
+  return info;
 }
 
 static void
diff --git a/gdb/infcall.c b/gdb/infcall.c
index 84092d37e64..9b833643dcc 100644
--- a/gdb/infcall.c
+++ b/gdb/infcall.c
@@ -985,7 +985,8 @@ call_function_by_hand_dummy (struct value *function,
       args[i] = value_arg_coerce (gdbarch, args[i],
 				  param_type, prototyped, &sp);
 
-      if (param_type != NULL && language_pass_by_reference (param_type))
+      if (param_type != NULL
+	  && !(language_pass_by_reference (param_type).trivially_copyable))
 	args[i] = value_addr (args[i]);
     }
 
diff --git a/gdb/language.c b/gdb/language.c
index a7c09ccd6db..85066033606 100644
--- a/gdb/language.c
+++ b/gdb/language.c
@@ -652,21 +652,24 @@ language_class_name_from_physname (const struct language_defn *lang,
   return NULL;
 }
 
-/* Return non-zero if TYPE should be passed (and returned) by
-   reference at the language level.  */
-int
+/* Return information about whether TYPE should be passed
+   (and returned) by reference at the language level.  */
+
+struct language_pass_by_ref_info
 language_pass_by_reference (struct type *type)
 {
   return current_language->la_pass_by_reference (type);
 }
 
-/* Return zero; by default, types are passed by value at the language
-   level.  The target ABI may pass or return some structs by reference
-   independent of this.  */
-int
+/* Return a default struct that provides pass-by-reference information
+   about the given TYPE.  Languages should update the default values
+   as appropriate.  */
+
+struct language_pass_by_ref_info
 default_pass_by_reference (struct type *type)
 {
-  return 0;
+  struct language_pass_by_ref_info info;
+  return info;
 }
 
 /* Return the default string containing the list of characters
diff --git a/gdb/language.h b/gdb/language.h
index e7446efa07f..c3afe30a2d0 100644
--- a/gdb/language.h
+++ b/gdb/language.h
@@ -128,6 +128,55 @@ struct language_arch_info
   struct type *bool_type_default;
 };
 
+/* In a language (particularly C++) a function argument of an aggregate
+   type (i.e.  class/struct/union) may be implicitly passed by reference
+   even though it is declared a call-by-value argument in the source.
+   The struct below puts together necessary information for GDB to be
+   able to detect and carry out pass-by-reference semantics for a
+   particular type.  This type is referred as T in the inlined comments
+   below.
+
+   The default values of the fields are chosen to give correct semantics
+   for primitive types and for simple aggregate types, such as
+
+   class T {
+     int x;
+   };  */
+
+struct language_pass_by_ref_info
+{
+  /* Name of the copy ctor function of T.  Expected to be
+     fully-qualified.  */
+  const char *cctor_name = nullptr;
+
+  /* Name of the destructor function of T.  Expected to be
+     fully-qualified.  */
+  const char *dtor_name = nullptr;
+
+  /* True if an argument of type T can be passed to a function by value
+     (i.e.  not through an implicit reference).  False, otherwise.  */
+  bool trivially_copyable = true;
+
+  /* True if a copy of a value of type T can be initialized by
+     memcpy'ing the value bit-by-bit.  False, otherwise.
+     E.g.  If T has a user-defined copy ctor, this should be false.  */
+  bool trivially_copy_constructible = true;
+
+  /* True if a value of type T can be destructed simply by reclaiming
+     the memory area occupied by the value.  False, otherwise.
+     E.g.  If T has a user-defined destructor, this should be false.  */
+  bool trivially_destructible = true;
+
+  /* True if it is allowed to create a copy of a value of type T.
+     False, otherwise.
+     E.g.  If T has a deleted copy ctor, this should be false.  */
+  bool copy_constructible = true;
+
+  /* True if a value of type T can be destructed.  False, otherwise.
+     E.g.  If T has a deleted destructor, this should be false.  */
+  bool destructible = true;
+};
+
 /* Structure tying together assorted information about a language.  */
 
 struct language_defn
@@ -356,9 +405,10 @@ struct language_defn
                                   struct ui_file *stream,
                                   const struct value_print_options *options);
 
-    /* Return non-zero if TYPE should be passed (and returned) by
-       reference at the language level.  */
-    int (*la_pass_by_reference) (struct type *type);
+    /* Return information about whether TYPE should be passed
+       (and returned) by reference at the language level.  */
+    struct language_pass_by_ref_info (*la_pass_by_reference)
+      (struct type *type);
 
     /* Obtain a string from the inferior, storing it in a newly allocated
        buffer in BUFFER, which should be freed by the caller.  If the
@@ -625,14 +675,14 @@ extern void default_print_array_index (struct value *index_value,
                                        struct ui_file *stream,
 				       const struct value_print_options *options);
 
-/* Return non-zero if TYPE should be passed (and returned) by
-   reference at the language level.  */
-int language_pass_by_reference (struct type *type);
+/* Return information about whether TYPE should be passed
+   (and returned) by reference at the language level.  */
+struct language_pass_by_ref_info language_pass_by_reference (struct type *type);
 
-/* Return zero; by default, types are passed by value at the language
-   level.  The target ABI may pass or return some structs by reference
-   independent of this.  */
-int default_pass_by_reference (struct type *type);
+/* Return a default struct that provides pass-by-reference information
+   about the given TYPE.  Languages should update the default values
+   as appropriate.  */
+struct language_pass_by_ref_info default_pass_by_reference (struct type *type);
 
 /* The default implementation of la_print_typedef.  */
 void default_print_typedef (struct type *type, struct symbol *new_symbol,
diff --git a/gdb/tic6x-tdep.c b/gdb/tic6x-tdep.c
index 2df83c4f619..ca059f91b58 100644
--- a/gdb/tic6x-tdep.c
+++ b/gdb/tic6x-tdep.c
@@ -784,7 +784,7 @@ tic6x_return_value (struct gdbarch *gdbarch, struct value *function,
       if (type != NULL)
 	{
 	  type = check_typedef (type);
-	  if (language_pass_by_reference (type))
+	  if (!(language_pass_by_reference (type).trivially_copyable))
 	    return RETURN_VALUE_STRUCT_CONVENTION;
 	}
     }
-- 
2.17.1

[PATCH v2 6/8] infcall: remove unused parameter in 'value_arg_coerce'

[Tankut Baris Aktemur]

Remove the unused SP parameter from the auxiliary function
'value_arg_coerce'.

gdb/ChangeLog:

2019-MM-DD  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>

	* infcall.c (value_arg_coerce): Remove an unused parameter.
	(call_function_by_hand_dummy): Update.

2019-06-24  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>
---
 gdb/infcall.c | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/gdb/infcall.c b/gdb/infcall.c
index f3e244620e8..e81df995ff5 100644
--- a/gdb/infcall.c
+++ b/gdb/infcall.c
@@ -145,13 +145,11 @@ show_unwind_on_terminating_exception_p (struct ui_file *file, int from_tty,
    for arguments to be passed to C, Ada or Fortran functions.
 
    If PARAM_TYPE is non-NULL, it is the expected parameter type.
-   IS_PROTOTYPED is non-zero if the function declaration is prototyped.
-   SP is the stack pointer were additional data can be pushed (updating
-   its value as needed).  */
+   IS_PROTOTYPED is non-zero if the function declaration is prototyped.  */
 
 static struct value *
 value_arg_coerce (struct gdbarch *gdbarch, struct value *arg,
-		  struct type *param_type, int is_prototyped, CORE_ADDR *sp)
+		  struct type *param_type, int is_prototyped)
 {
   const struct builtin_type *builtin = builtin_type (gdbarch);
   struct type *arg_type = check_typedef (value_type (arg));
@@ -1020,7 +1018,7 @@ call_function_by_hand_dummy (struct value *function,
 	param_type = NULL;
 
       args[i] = value_arg_coerce (gdbarch, args[i],
-				  param_type, prototyped, &sp);
+				  param_type, prototyped);
 
       if (param_type != NULL
 	  && !(language_pass_by_reference (param_type).trivially_copyable))
-- 
2.17.1

RE: [PATCH v2 0/8] Fix inferior call for C++ pass-by-reference arguments

[Aktemur, Tankut Baris]

> -----Original Message-----
> 
> Hi All,
> 
> This is a set of patches to fix GDB's conformance to C++ ABI when
> invoking functions that have call-by-value arguments of aggregate
> types that should be implicitly passed by reference.
> 
> The v1 of the series is available at
> https://sourceware.org/ml/gdb-patches/2019-04/msg00461.html
> 
> Changes since v1:
> * Patches 1-3 have been revised according to the reviews
>   (thanks to Andrew Burgess).
> * The patches have been rebased to the current master.
> 
> Regards,
> -Baris

Kindly ping'ing.

Best regards,

-Baris


> 
> Tankut Baris Aktemur (8):
>   gdb: recognize new DWARF attributes: defaulted, deleted, calling conv.
>   infcall, c++: allow more info to be computed for pass-by-reference
>     values
>   infcall, c++: collect more pass-by-reference information
>   infcall: refactor 'call_function_by_hand_dummy'
>   infcall: move assertions in 'call_function_by_hand_dummy' to an
>     earlier spot
>   infcall: remove unused parameter in 'value_arg_coerce'
>   infcall: handle pass-by-reference arguments appropriately
>   testsuite, cp: increase the coverage of testing pass-by-ref arguments
> 
>  gdb/arch-utils.c                       |    2 +-
>  gdb/cp-abi.c                           |    6 +-
>  gdb/cp-abi.h                           |   10 +-
>  gdb/dwarf2read.c                       |   20 +
>  gdb/gdbtypes.c                         |    7 +
>  gdb/gdbtypes.h                         |   21 +-
>  gdb/gnu-v3-abi.c                       |  284 +-
>  gdb/infcall.c                          |  213 +-
>  gdb/language.c                         |   19 +-
>  gdb/language.h                         |   70 +-
>  gdb/testsuite/gdb.cp/pass-by-ref-2.cc  |  179 +
>  gdb/testsuite/gdb.cp/pass-by-ref-2.exp |   85 +
>  gdb/testsuite/gdb.cp/pass-by-ref.cc    | 7368 +++++++++++++++++++++++-
>  gdb/testsuite/gdb.cp/pass-by-ref.exp   |  412 +-
>  gdb/tic6x-tdep.c                       |    2 +-
>  15 files changed, 8538 insertions(+), 160 deletions(-)
>  create mode 100644 gdb/testsuite/gdb.cp/pass-by-ref-2.cc
>  create mode 100644 gdb/testsuite/gdb.cp/pass-by-ref-2.exp
> 
> --
> 2.17.1

Intel Deutschland GmbH
Registered Address: Am Campeon 10-12, 85579 Neubiberg, Germany
Tel: +49 89 99 8853-0, www.intel.de
Managing Directors: Christin Eisenschmid, Gary Kershaw
Chairperson of the Supervisory Board: Nicole Lau
Registered Office: Munich
Commercial Register: Amtsgericht Muenchen HRB 186928

RE: [PATCH v2 0/8] Fix inferior call for C++ pass-by-reference arguments

[Aktemur, Tankut Baris]

* On Monday, June 24, 2019 11:30 AM, Tankut Baris Aktemur wrote:
> Hi All,
> 
> This is a set of patches to fix GDB's conformance to C++ ABI when
> invoking functions that have call-by-value arguments of aggregate
> types that should be implicitly passed by reference.
> 
> The v1 of the series is available at
> https://sourceware.org/ml/gdb-patches/2019-04/msg00461.html
> 
> Changes since v1:
> * Patches 1-3 have been revised according to the reviews
>   (thanks to Andrew Burgess).
> * The patches have been rebased to the current master.
> 
> Regards,
> -Baris

Kindly pinging for the v2 of the series.
(https://sourceware.org/ml/gdb-patches/2019-06/msg00517.html)

Thanks,
-Baris

> 
> Tankut Baris Aktemur (8):
>   gdb: recognize new DWARF attributes: defaulted, deleted, calling conv.
>   infcall, c++: allow more info to be computed for pass-by-reference
>     values
>   infcall, c++: collect more pass-by-reference information
>   infcall: refactor 'call_function_by_hand_dummy'
>   infcall: move assertions in 'call_function_by_hand_dummy' to an
>     earlier spot
>   infcall: remove unused parameter in 'value_arg_coerce'
>   infcall: handle pass-by-reference arguments appropriately
>   testsuite, cp: increase the coverage of testing pass-by-ref arguments
> 
>  gdb/arch-utils.c                       |    2 +-
>  gdb/cp-abi.c                           |    6 +-
>  gdb/cp-abi.h                           |   10 +-
>  gdb/dwarf2read.c                       |   20 +
>  gdb/gdbtypes.c                         |    7 +
>  gdb/gdbtypes.h                         |   21 +-
>  gdb/gnu-v3-abi.c                       |  284 +-
>  gdb/infcall.c                          |  213 +-
>  gdb/language.c                         |   19 +-
>  gdb/language.h                         |   70 +-
>  gdb/testsuite/gdb.cp/pass-by-ref-2.cc  |  179 +
>  gdb/testsuite/gdb.cp/pass-by-ref-2.exp |   85 +
>  gdb/testsuite/gdb.cp/pass-by-ref.cc    | 7368 +++++++++++++++++++++++-
>  gdb/testsuite/gdb.cp/pass-by-ref.exp   |  412 +-
>  gdb/tic6x-tdep.c                       |    2 +-
>  15 files changed, 8538 insertions(+), 160 deletions(-)
>  create mode 100644 gdb/testsuite/gdb.cp/pass-by-ref-2.cc
>  create mode 100644 gdb/testsuite/gdb.cp/pass-by-ref-2.exp
> 
> --
> 2.17.1

Intel Deutschland GmbH
Registered Address: Am Campeon 10-12, 85579 Neubiberg, Germany
Tel: +49 89 99 8853-0, www.intel.de
Managing Directors: Christin Eisenschmid, Gary Kershaw
Chairperson of the Supervisory Board: Nicole Lau
Registered Office: Munich
Commercial Register: Amtsgericht Muenchen HRB 186928